Merge pull request #79813 from glessard/unchecked-bounds-are-unsafe

glessard · web-flow · commit 077a01f8077a · 2025-03-07T12:20:05.000-08:00
[stdlib] Unchecked bounds are unsafe
diff --git a/stdlib/public/core/ClosedRange.swift b/stdlib/public/core/ClosedRange.swift
@@ -70,6 +70,7 @@ public struct ClosedRange<Bound: Comparable> {
 
   // This works around _debugPrecondition() impacting the performance of
   // optimized code. (rdar://72246338)
+  @unsafe
   @_alwaysEmitIntoClient @inline(__always)
   internal init(_uncheckedBounds bounds: (lower: Bound, upper: Bound)) {
     self.lowerBound = bounds.lower
@@ -89,7 +90,9 @@ public struct ClosedRange<Bound: Comparable> {
   public init(uncheckedBounds bounds: (lower: Bound, upper: Bound)) {
     _debugPrecondition(bounds.lower <= bounds.upper,
       "ClosedRange requires lowerBound <= upperBound")
-    self.init(_uncheckedBounds: (lower: bounds.lower, upper: bounds.upper))
+    unsafe self.init(
+      _uncheckedBounds: (lower: bounds.lower, upper: bounds.upper)
+    )
   }
 }
 
@@ -109,7 +112,7 @@ extension ClosedRange: RangeExpression {
   @inlinable // trivial-implementation
   public func relative<C: Collection>(to collection: C) -> Range<Bound>
   where C.Index == Bound {
-    return Range(
+    return unsafe Range(
       _uncheckedBounds: (
         lower: lowerBound,
         upper: collection.index(after: self.upperBound)))
@@ -405,7 +408,7 @@ extension Comparable {
   public static func ... (minimum: Self, maximum: Self) -> ClosedRange<Self> {
     _precondition(
       minimum <= maximum, "Range requires lowerBound <= upperBound")
-    return ClosedRange(_uncheckedBounds: (lower: minimum, upper: maximum))
+    return unsafe ClosedRange(_uncheckedBounds: (lower: minimum, upper: maximum))
   }
 }
 
@@ -496,7 +499,7 @@ extension ClosedRange {
       limits.upperBound < self.upperBound ? limits.upperBound
           : limits.lowerBound > self.upperBound ? limits.lowerBound
           : self.upperBound
-    return ClosedRange(_uncheckedBounds: (lower: lower, upper: upper))
+    return unsafe ClosedRange(_uncheckedBounds: (lower: lower, upper: upper))
   }
 }
 
@@ -512,7 +515,9 @@ extension ClosedRange where Bound: Strideable, Bound.Stride: SignedInteger {
   public init(_ other: Range<Bound>) {
     _precondition(!other.isEmpty, "Can't form an empty closed range")
     let upperBound = other.upperBound.advanced(by: -1)
-    self.init(_uncheckedBounds: (lower: other.lowerBound, upper: upperBound))
+    unsafe self.init(
+      _uncheckedBounds: (lower: other.lowerBound, upper: upperBound)
+    )
   }
 }
 
@@ -581,7 +586,7 @@ extension ClosedRange: Decodable where Bound: Decodable {
           codingPath: decoder.codingPath,
           debugDescription: "Cannot initialize \(ClosedRange.self) with a lowerBound (\(lowerBound)) greater than upperBound (\(upperBound))"))
     }
-    self.init(_uncheckedBounds: (lower: lowerBound, upper: upperBound))
+    unsafe self.init(_uncheckedBounds: (lower: lowerBound, upper: upperBound))
   }
 }
 
diff --git a/stdlib/public/core/InlineArray.swift b/stdlib/public/core/InlineArray.swift
@@ -294,7 +294,7 @@ extension InlineArray where Element: ~Copyable {
   @_alwaysEmitIntoClient
   @_transparent
   public var indices: Range<Int> {
-    Range(_uncheckedBounds: (0, count))
+    unsafe Range(_uncheckedBounds: (0, count))
   }
 
   /// Returns the position immediately after the given index.
diff --git a/stdlib/public/core/Range.swift b/stdlib/public/core/Range.swift
@@ -159,6 +159,7 @@ public struct Range<Bound: Comparable> {
 
   // This works around _debugPrecondition() impacting the performance of
   // optimized code. (rdar://72246338)
+  @unsafe
   @_alwaysEmitIntoClient @inline(__always)
   internal init(_uncheckedBounds bounds: (lower: Bound, upper: Bound)) {
     self.lowerBound = bounds.lower
@@ -178,7 +179,9 @@ public struct Range<Bound: Comparable> {
   public init(uncheckedBounds bounds: (lower: Bound, upper: Bound)) {
     _debugPrecondition(bounds.lower <= bounds.upper,
       "Range requires lowerBound <= upperBound")
-    self.init(_uncheckedBounds: (lower: bounds.lower, upper: bounds.upper))
+    unsafe self.init(
+      _uncheckedBounds: (lower: bounds.lower, upper: bounds.upper)
+    )
   }
 
   /// Returns a Boolean value indicating whether the given element is contained
@@ -321,7 +324,9 @@ extension Range where Bound: Strideable, Bound.Stride: SignedInteger {
   @inlinable // trivial-implementation
   public init(_ other: ClosedRange<Bound>) {
     let upperBound = other.upperBound.advanced(by: 1)
-    self.init(_uncheckedBounds: (lower: other.lowerBound, upper: upperBound))
+    unsafe self.init(
+      _uncheckedBounds: (lower: other.lowerBound, upper: upperBound)
+    )
   }
 }
 
@@ -372,7 +377,7 @@ extension Range {
       limits.upperBound < self.upperBound ? limits.upperBound
           : limits.lowerBound > self.upperBound ? limits.lowerBound
           : self.upperBound
-    return Range(_uncheckedBounds: (lower: lower, upper: upper))
+    return unsafe Range(_uncheckedBounds: (lower: lower, upper: upper))
   }
 }
 
@@ -453,7 +458,7 @@ extension Range: Decodable where Bound: Decodable {
           codingPath: decoder.codingPath,
           debugDescription: "Cannot initialize \(Range.self) with a lowerBound (\(lowerBound)) greater than upperBound (\(upperBound))"))
     }
-    self.init(_uncheckedBounds: (lower: lowerBound, upper: upperBound))
+    unsafe self.init(_uncheckedBounds: (lower: lowerBound, upper: upperBound))
   }
 }
 
@@ -754,7 +759,7 @@ extension Comparable {
   public static func ..< (minimum: Self, maximum: Self) -> Range<Self> {
     _precondition(minimum <= maximum,
       "Range requires lowerBound <= upperBound")
-    return Range(_uncheckedBounds: (lower: minimum, upper: maximum))
+    return unsafe Range(_uncheckedBounds: (lower: minimum, upper: maximum))
   }
 
   /// Returns a partial range up to, but not including, its upper bound.
@@ -1123,7 +1128,7 @@ extension Range where Bound == String.Index {
     _internalInvariant(
       (lowerBound._canBeUTF8 && upperBound._canBeUTF8)
       || (lowerBound._canBeUTF16 && upperBound._canBeUTF16))
-    return Range<Int>(
+    return unsafe Range<Int>(
       _uncheckedBounds: (lowerBound._encodedOffset, upperBound._encodedOffset))
   }
 }
diff --git a/stdlib/public/core/Slice.swift b/stdlib/public/core/Slice.swift
@@ -138,7 +138,7 @@ public struct Slice<Base: Collection> {
 
   @_alwaysEmitIntoClient @inline(__always)
   internal var _bounds: Range<Base.Index> {
-    Range(_uncheckedBounds: (_startIndex, _endIndex))
+    unsafe Range(_uncheckedBounds: (_startIndex, _endIndex))
   }
 }
 
diff --git a/stdlib/public/core/Span/RawSpan.swift b/stdlib/public/core/Span/RawSpan.swift
@@ -322,7 +322,7 @@ extension RawSpan {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   public var byteOffsets: Range<Int> {
-    .init(_uncheckedBounds: (0, byteCount))
+    unsafe Range(_uncheckedBounds: (0, byteCount))
   }
 }
 
@@ -629,13 +629,13 @@ extension RawSpan {
   public func byteOffsets(of other: borrowing Self) -> Range<Int>? {
     if other._count > _count { return nil }
     guard let spanStart = other._pointer, _count > 0 else {
-      return unsafe _pointer == other._pointer ? Range(_uncheckedBounds: (0, 0)) : nil
+      return unsafe _pointer == other._pointer ? 0..<0 : nil
     }
     let start = _start()
     let spanEnd = unsafe spanStart + other._count
     if unsafe spanStart < start || (start + _count) < spanEnd { return nil }
     let lower = unsafe start.distance(to: spanStart)
-    return Range(_uncheckedBounds: (lower, lower &+ other._count))
+    return unsafe Range(_uncheckedBounds: (lower, lower &+ other._count))
   }
 }
 
diff --git a/stdlib/public/core/Span/Span.swift b/stdlib/public/core/Span/Span.swift
@@ -395,7 +395,7 @@ extension Span where Element: ~Copyable {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   public var indices: Range<Index> {
-    Range(_uncheckedBounds: (0, _count))
+    unsafe Range(_uncheckedBounds: (0, _count))
   }
 }
 
@@ -679,7 +679,7 @@ extension Span where Element: ~Copyable {
   public func indices(of other: borrowing Self) -> Range<Index>? {
     if other._count > _count { return nil }
     guard let spanStart = other._pointer, _count > 0 else {
-      return unsafe _pointer == other._pointer ? Range(_uncheckedBounds: (0, 0)) : nil
+      return unsafe _pointer == other._pointer ? 0..<0 : nil
     }
     let start = _start()
     let stride = MemoryLayout<Element>.stride
@@ -688,7 +688,7 @@ extension Span where Element: ~Copyable {
     let byteOffset = unsafe start.distance(to: spanStart)
     let (lower, r) = byteOffset.quotientAndRemainder(dividingBy: stride)
     guard r == 0 else { return nil }
-    return Range(_uncheckedBounds: (lower, lower &+ other._count))
+    return unsafe Range(_uncheckedBounds: (lower, lower &+ other._count))
   }
 }
 
diff --git a/stdlib/public/core/StringGraphemeBreaking.swift b/stdlib/public/core/StringGraphemeBreaking.swift
@@ -599,7 +599,7 @@ extension Unicode {
       while i < buffer.endIndex {
         let (next, n) = unsafe _decodeScalar(buffer, startingAt: i)
         if hasBreak(before: next) {
-          return Range(_uncheckedBounds: (i, i &+ n))
+          return unsafe Range(_uncheckedBounds: (i, i &+ n))
         }
         i &+= n
       }
diff --git a/stdlib/public/core/StringGutsRangeReplaceable.swift b/stdlib/public/core/StringGutsRangeReplaceable.swift
@@ -367,7 +367,7 @@ extension _StringGuts {
     let j = result._guts.count
     result.append(contentsOf: selfStr[bounds.upperBound...])
     self = result._guts
-    return Range(_uncheckedBounds: (i, j))
+    return unsafe Range(_uncheckedBounds: (i, j))
   }
 
   // - Returns: The encoded offset range of the replaced contents in the result.
@@ -421,7 +421,7 @@ extension _StringGuts {
     let j = result._guts.count
     result.append(contentsOf: selfStr[bounds.upperBound...])
     self = result._guts
-    return Range(_uncheckedBounds: (i, j))
+    return unsafe Range(_uncheckedBounds: (i, j))
   }
 
   // - Returns: The encoded offset range of the replaced contents in the result.
@@ -443,7 +443,7 @@ extension _StringGuts {
     updateNativeStorage {
       unsafe $0.replace(from: start, to: end, with: codeUnits)
     }
-    return Range(_uncheckedBounds: (start, start + codeUnits.count))
+    return unsafe Range(_uncheckedBounds: (start, start + codeUnits.count))
   }
 
   // - Returns: The encoded offset range of the replaced contents in the result.
@@ -468,7 +468,7 @@ extension _StringGuts {
       $0.replace(
         from: start, to: end, with: codeUnits, replacementCount: replCount)
     }
-    return Range(_uncheckedBounds: (start, start + replCount))
+    return unsafe Range(_uncheckedBounds: (start, start + replCount))
   }
 
   /// Run `body` to mutate the given `subrange` of this string within
@@ -540,9 +540,9 @@ extension _StringGuts {
     let oldRange = subrange._encodedOffsetRange
     let newRange = body(&self)
 
-    let oldBounds = Range(
+    let oldBounds = unsafe Range(
       _uncheckedBounds: (startIndex._encodedOffset, endIndex._encodedOffset))
-    let newBounds = Range(_uncheckedBounds: (
+    let newBounds = unsafe Range(_uncheckedBounds: (
         oldBounds.lowerBound,
         oldBounds.upperBound &+ newRange.count &- oldRange.count))
 
diff --git a/stdlib/public/core/StringGutsSlice.swift b/stdlib/public/core/StringGutsSlice.swift
@@ -24,7 +24,7 @@ internal struct _StringGutsSlice {
   @inline(__always)
   internal init(_ guts: _StringGuts) {
     self._guts = guts
-    self._offsetRange = Range(_uncheckedBounds: (0, guts.count))
+    self._offsetRange = unsafe Range(_uncheckedBounds: (0, guts.count))
   }
 
   @inline(__always)
@@ -74,7 +74,7 @@ internal struct _StringGutsSlice {
         ._scalarAligned
       let higher = String.Index(_encodedOffset: _offsetRange.upperBound)
         ._scalarAligned
-      return Range(_uncheckedBounds: (lower, higher))
+      return unsafe Range(_uncheckedBounds: (lower, higher))
     }
   }
 
diff --git a/stdlib/public/core/StringIndexValidation.swift b/stdlib/public/core/StringIndexValidation.swift
@@ -80,7 +80,7 @@ extension _StringGuts {
     _precondition(upper <= endIndex && lower <= upper,
       "String index range is out of bounds")
 
-    return Range(_uncheckedBounds: (lower, upper))
+    return unsafe Range(_uncheckedBounds: (lower, upper))
   }
 
   @_alwaysEmitIntoClient
@@ -102,7 +102,7 @@ extension _StringGuts {
       && upper <= bounds.upperBound,
       "Substring index range is out of bounds")
 
-    return Range(_uncheckedBounds: (lower, upper))
+    return unsafe Range(_uncheckedBounds: (lower, upper))
   }
 }
 
@@ -213,7 +213,7 @@ extension _StringGuts {
     }
 
     let r = validateSubscalarRange(range)
-    return Range(
+    return unsafe Range(
       _uncheckedBounds: (scalarAlign(r.lowerBound), scalarAlign(r.upperBound)))
   }
 
@@ -243,7 +243,7 @@ extension _StringGuts {
     let r = validateSubscalarRange(range, in: bounds)
     let upper = scalarAlign(r.upperBound)
     let lower = scalarAlign(r.lowerBound)
-    return Range(_uncheckedBounds: (lower, upper))
+    return unsafe Range(_uncheckedBounds: (lower, upper))
   }
 }
 
@@ -356,7 +356,7 @@ extension _StringGuts {
     _precondition(upper <= endIndex && lower <= upper,
       "String index range is out of bounds")
 
-    return Range(_uncheckedBounds: (lower, upper))
+    return unsafe Range(_uncheckedBounds: (lower, upper))
   }
 
   /// A version of `validateScalarRange` that only traps if the main executable
@@ -377,7 +377,7 @@ extension _StringGuts {
     }
 
     let r = validateSubscalarRange_5_7(range)
-    return Range(
+    return unsafe Range(
       _uncheckedBounds: (scalarAlign(r.lowerBound), scalarAlign(r.upperBound)))
   }
 
diff --git a/stdlib/public/core/StringProtocol.swift b/stdlib/public/core/StringProtocol.swift
@@ -153,7 +153,9 @@ extension StringProtocol {
       let end = endIndex
       _internalInvariant(
         start.transcodedOffset == 0 && end.transcodedOffset == 0)
-      return Range(_uncheckedBounds: (start._encodedOffset, end._encodedOffset))
+      return unsafe Range(
+        _uncheckedBounds: (start._encodedOffset, end._encodedOffset)
+      )
     }
   }
 
diff --git a/stdlib/public/core/StringRangeReplaceableCollection.swift b/stdlib/public/core/StringRangeReplaceableCollection.swift
@@ -218,7 +218,7 @@ extension String: RangeReplaceableCollection {
   /// - Complexity: O(*n*), where *n* is the length of the string.
   public mutating func insert(_ newElement: Character, at i: Index) {
     let i = _guts.validateInclusiveScalarIndex(i)
-    let range = Range(_uncheckedBounds: (i, i))
+    let range = unsafe Range(_uncheckedBounds: (i, i))
     _guts.replaceSubrange(range, with: newElement._str)
   }
 
@@ -243,7 +243,7 @@ extension String: RangeReplaceableCollection {
     contentsOf newElements: S, at i: Index
   ) where S.Element == Character {
     let i = _guts.validateInclusiveScalarIndex(i)
-    let range = Range(_uncheckedBounds: (i, i))
+    let range = unsafe Range(_uncheckedBounds: (i, i))
     _guts.replaceSubrange(range, with: newElements)
   }
 
diff --git a/stdlib/public/core/StringStorageBridge.swift b/stdlib/public/core/StringStorageBridge.swift
@@ -54,7 +54,7 @@ extension _AbstractStringStorage {
     _precondition(aRange.location + aRange.length <= Int(count),
                   "Range out of bounds")
 
-    let range = Range(
+    let range = unsafe Range(
       _uncheckedBounds: (aRange.location, aRange.location+aRange.length))
     let str = asString
     unsafe str._copyUTF16CodeUnits(
diff --git a/stdlib/public/core/Substring.swift b/stdlib/public/core/Substring.swift

Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,7 @@ public struct ClosedRange<Bound: Comparable> {`
`70`	`70`
`71`	`71`	`// This works around _debugPrecondition() impacting the performance of`
`72`	`72`	`// optimized code. (rdar://72246338)`
	`73`	`+ @unsafe`
`73`	`74`	`@_alwaysEmitIntoClient @inline(__always)`
`74`	`75`	`internal init(_uncheckedBounds bounds: (lower: Bound, upper: Bound)) {`
`75`	`76`	`self.lowerBound = bounds.lower`
`@@ -89,7 +90,9 @@ public struct ClosedRange<Bound: Comparable> {`
`89`	`90`	`public init(uncheckedBounds bounds: (lower: Bound, upper: Bound)) {`
`90`	`91`	`_debugPrecondition(bounds.lower <= bounds.upper,`
`91`	`92`	`"ClosedRange requires lowerBound <= upperBound")`
`92`		`- self.init(_uncheckedBounds: (lower: bounds.lower, upper: bounds.upper))`
	`93`	`+ unsafe self.init(`
	`94`	`+ _uncheckedBounds: (lower: bounds.lower, upper: bounds.upper)`
	`95`	`+ )`
`93`	`96`	`}`
`94`	`97`	`}`
`95`	`98`
`@@ -109,7 +112,7 @@ extension ClosedRange: RangeExpression {`
`109`	`112`	`@inlinable // trivial-implementation`
`110`	`113`	`public func relative<C: Collection>(to collection: C) -> Range<Bound>`
`111`	`114`	`where C.Index == Bound {`
`112`		`- return Range(`
	`115`	`+ return unsafe Range(`
`113`	`116`	`_uncheckedBounds: (`
`114`	`117`	`lower: lowerBound,`
`115`	`118`	`upper: collection.index(after: self.upperBound)))`
`@@ -405,7 +408,7 @@ extension Comparable {`
`405`	`408`	`public static func ... (minimum: Self, maximum: Self) -> ClosedRange<Self> {`
`406`	`409`	`_precondition(`
`407`	`410`	`minimum <= maximum, "Range requires lowerBound <= upperBound")`
`408`		`- return ClosedRange(_uncheckedBounds: (lower: minimum, upper: maximum))`
	`411`	`+ return unsafe ClosedRange(_uncheckedBounds: (lower: minimum, upper: maximum))`
`409`	`412`	`}`
`410`	`413`	`}`
`411`	`414`
`@@ -496,7 +499,7 @@ extension ClosedRange {`
`496`	`499`	`limits.upperBound < self.upperBound ? limits.upperBound`
`497`	`500`	`: limits.lowerBound > self.upperBound ? limits.lowerBound`
`498`	`501`	`: self.upperBound`
`499`		`- return ClosedRange(_uncheckedBounds: (lower: lower, upper: upper))`
	`502`	`+ return unsafe ClosedRange(_uncheckedBounds: (lower: lower, upper: upper))`
`500`	`503`	`}`
`501`	`504`	`}`
`502`	`505`
`@@ -512,7 +515,9 @@ extension ClosedRange where Bound: Strideable, Bound.Stride: SignedInteger {`
`512`	`515`	`public init(_ other: Range<Bound>) {`
`513`	`516`	`_precondition(!other.isEmpty, "Can't form an empty closed range")`
`514`	`517`	`let upperBound = other.upperBound.advanced(by: -1)`
`515`		`- self.init(_uncheckedBounds: (lower: other.lowerBound, upper: upperBound))`
	`518`	`+ unsafe self.init(`
	`519`	`+ _uncheckedBounds: (lower: other.lowerBound, upper: upperBound)`
	`520`	`+ )`
`516`	`521`	`}`
`517`	`522`	`}`
`518`	`523`
`@@ -581,7 +586,7 @@ extension ClosedRange: Decodable where Bound: Decodable {`
`581`	`586`	`codingPath: decoder.codingPath,`
`582`	`587`	`debugDescription: "Cannot initialize \(ClosedRange.self) with a lowerBound (\(lowerBound)) greater than upperBound (\(upperBound))"))`
`583`	`588`	`}`
`584`		`- self.init(_uncheckedBounds: (lower: lowerBound, upper: upperBound))`
	`589`	`+ unsafe self.init(_uncheckedBounds: (lower: lowerBound, upper: upperBound))`
`585`	`590`	`}`
`586`	`591`	`}`
`587`	`592`
Original file line number	Diff line number	Diff line change
`@@ -294,7 +294,7 @@ extension InlineArray where Element: ~Copyable {`
`294`	`294`	`@_alwaysEmitIntoClient`
`295`	`295`	`@_transparent`
`296`	`296`	`public var indices: Range<Int> {`
`297`		`- Range(_uncheckedBounds: (0, count))`
	`297`	`+ unsafe Range(_uncheckedBounds: (0, count))`
`298`	`298`	`}`
`299`	`299`
`300`	`300`	`/// Returns the position immediately after the given index.`
Original file line number	Diff line number	Diff line change
`@@ -159,6 +159,7 @@ public struct Range<Bound: Comparable> {`
`159`	`159`
`160`	`160`	`// This works around _debugPrecondition() impacting the performance of`
`161`	`161`	`// optimized code. (rdar://72246338)`
	`162`	`+ @unsafe`
`162`	`163`	`@_alwaysEmitIntoClient @inline(__always)`
`163`	`164`	`internal init(_uncheckedBounds bounds: (lower: Bound, upper: Bound)) {`
`164`	`165`	`self.lowerBound = bounds.lower`
`@@ -178,7 +179,9 @@ public struct Range<Bound: Comparable> {`
`178`	`179`	`public init(uncheckedBounds bounds: (lower: Bound, upper: Bound)) {`
`179`	`180`	`_debugPrecondition(bounds.lower <= bounds.upper,`
`180`	`181`	`"Range requires lowerBound <= upperBound")`
`181`		`- self.init(_uncheckedBounds: (lower: bounds.lower, upper: bounds.upper))`
	`182`	`+ unsafe self.init(`
	`183`	`+ _uncheckedBounds: (lower: bounds.lower, upper: bounds.upper)`
	`184`	`+ )`
`182`	`185`	`}`
`183`	`186`
`184`	`187`	`/// Returns a Boolean value indicating whether the given element is contained`
`@@ -321,7 +324,9 @@ extension Range where Bound: Strideable, Bound.Stride: SignedInteger {`
`321`	`324`	`@inlinable // trivial-implementation`
`322`	`325`	`public init(_ other: ClosedRange<Bound>) {`
`323`	`326`	`let upperBound = other.upperBound.advanced(by: 1)`
`324`		`- self.init(_uncheckedBounds: (lower: other.lowerBound, upper: upperBound))`
	`327`	`+ unsafe self.init(`
	`328`	`+ _uncheckedBounds: (lower: other.lowerBound, upper: upperBound)`
	`329`	`+ )`
`325`	`330`	`}`
`326`	`331`	`}`
`327`	`332`
`@@ -372,7 +377,7 @@ extension Range {`
`372`	`377`	`limits.upperBound < self.upperBound ? limits.upperBound`
`373`	`378`	`: limits.lowerBound > self.upperBound ? limits.lowerBound`
`374`	`379`	`: self.upperBound`
`375`		`- return Range(_uncheckedBounds: (lower: lower, upper: upper))`
	`380`	`+ return unsafe Range(_uncheckedBounds: (lower: lower, upper: upper))`
`376`	`381`	`}`
`377`	`382`	`}`
`378`	`383`
`@@ -453,7 +458,7 @@ extension Range: Decodable where Bound: Decodable {`
`453`	`458`	`codingPath: decoder.codingPath,`
`454`	`459`	`debugDescription: "Cannot initialize \(Range.self) with a lowerBound (\(lowerBound)) greater than upperBound (\(upperBound))"))`
`455`	`460`	`}`
`456`		`- self.init(_uncheckedBounds: (lower: lowerBound, upper: upperBound))`
	`461`	`+ unsafe self.init(_uncheckedBounds: (lower: lowerBound, upper: upperBound))`
`457`	`462`	`}`
`458`	`463`	`}`
`459`	`464`
`@@ -754,7 +759,7 @@ extension Comparable {`
`754`	`759`	`public static func ..< (minimum: Self, maximum: Self) -> Range<Self> {`
`755`	`760`	`_precondition(minimum <= maximum,`
`756`	`761`	`"Range requires lowerBound <= upperBound")`
`757`		`- return Range(_uncheckedBounds: (lower: minimum, upper: maximum))`
	`762`	`+ return unsafe Range(_uncheckedBounds: (lower: minimum, upper: maximum))`
`758`	`763`	`}`
`759`	`764`
`760`	`765`	`/// Returns a partial range up to, but not including, its upper bound.`
`@@ -1123,7 +1128,7 @@ extension Range where Bound == String.Index {`
`1123`	`1128`	`_internalInvariant(`
`1124`	`1129`	`(lowerBound._canBeUTF8 && upperBound._canBeUTF8)`
`1125`	`1130`	`\|\| (lowerBound._canBeUTF16 && upperBound._canBeUTF16))`
`1126`		`- return Range<Int>(`
	`1131`	`+ return unsafe Range<Int>(`
`1127`	`1132`	`_uncheckedBounds: (lowerBound._encodedOffset, upperBound._encodedOffset))`
`1128`	`1133`	`}`
`1129`	`1134`	`}`
Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ public struct Slice<Base: Collection> {`
`138`	`138`
`139`	`139`	`@_alwaysEmitIntoClient @inline(__always)`
`140`	`140`	`internal var _bounds: Range<Base.Index> {`
`141`		`- Range(_uncheckedBounds: (_startIndex, _endIndex))`
	`141`	`+ unsafe Range(_uncheckedBounds: (_startIndex, _endIndex))`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
Original file line number	Diff line number	Diff line change
`@@ -322,7 +322,7 @@ extension RawSpan {`
`322`	`322`	`/// - Complexity: O(1)`
`323`	`323`	`@_alwaysEmitIntoClient`
`324`	`324`	`public var byteOffsets: Range<Int> {`
`325`		`- .init(_uncheckedBounds: (0, byteCount))`
	`325`	`+ unsafe Range(_uncheckedBounds: (0, byteCount))`
`326`	`326`	`}`
`327`	`327`	`}`
`328`	`328`
`@@ -629,13 +629,13 @@ extension RawSpan {`
`629`	`629`	`public func byteOffsets(of other: borrowing Self) -> Range<Int>? {`
`630`	`630`	`if other._count > _count { return nil }`
`631`	`631`	`guard let spanStart = other._pointer, _count > 0 else {`
`632`		`- return unsafe _pointer == other._pointer ? Range(_uncheckedBounds: (0, 0)) : nil`
	`632`	`+ return unsafe _pointer == other._pointer ? 0..<0 : nil`
`633`	`633`	`}`
`634`	`634`	`let start = _start()`
`635`	`635`	`let spanEnd = unsafe spanStart + other._count`
`636`	`636`	`if unsafe spanStart < start \|\| (start + _count) < spanEnd { return nil }`
`637`	`637`	`let lower = unsafe start.distance(to: spanStart)`
`638`		`- return Range(_uncheckedBounds: (lower, lower &+ other._count))`
	`638`	`+ return unsafe Range(_uncheckedBounds: (lower, lower &+ other._count))`
`639`	`639`	`}`
`640`	`640`	`}`
`641`	`641`
Original file line number	Diff line number	Diff line change
`@@ -395,7 +395,7 @@ extension Span where Element: ~Copyable {`
`395`	`395`	`/// - Complexity: O(1)`
`396`	`396`	`@_alwaysEmitIntoClient`
`397`	`397`	`public var indices: Range<Index> {`
`398`		`- Range(_uncheckedBounds: (0, _count))`
	`398`	`+ unsafe Range(_uncheckedBounds: (0, _count))`
`399`	`399`	`}`
`400`	`400`	`}`
`401`	`401`
`@@ -679,7 +679,7 @@ extension Span where Element: ~Copyable {`
`679`	`679`	`public func indices(of other: borrowing Self) -> Range<Index>? {`
`680`	`680`	`if other._count > _count { return nil }`
`681`	`681`	`guard let spanStart = other._pointer, _count > 0 else {`
`682`		`- return unsafe _pointer == other._pointer ? Range(_uncheckedBounds: (0, 0)) : nil`
	`682`	`+ return unsafe _pointer == other._pointer ? 0..<0 : nil`
`683`	`683`	`}`
`684`	`684`	`let start = _start()`
`685`	`685`	`let stride = MemoryLayout<Element>.stride`
`@@ -688,7 +688,7 @@ extension Span where Element: ~Copyable {`
`688`	`688`	`let byteOffset = unsafe start.distance(to: spanStart)`
`689`	`689`	`let (lower, r) = byteOffset.quotientAndRemainder(dividingBy: stride)`
`690`	`690`	`guard r == 0 else { return nil }`
`691`		`- return Range(_uncheckedBounds: (lower, lower &+ other._count))`
	`691`	`+ return unsafe Range(_uncheckedBounds: (lower, lower &+ other._count))`
`692`	`692`	`}`
`693`	`693`	`}`
`694`	`694`
Original file line number	Diff line number	Diff line change
`@@ -599,7 +599,7 @@ extension Unicode {`
`599`	`599`	`while i < buffer.endIndex {`
`600`	`600`	`let (next, n) = unsafe _decodeScalar(buffer, startingAt: i)`
`601`	`601`	`if hasBreak(before: next) {`
`602`		`- return Range(_uncheckedBounds: (i, i &+ n))`
	`602`	`+ return unsafe Range(_uncheckedBounds: (i, i &+ n))`
`603`	`603`	`}`
`604`	`604`	`i &+= n`
`605`	`605`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ internal struct _StringGutsSlice {`
`24`	`24`	`@inline(__always)`
`25`	`25`	`internal init(_ guts: _StringGuts) {`
`26`	`26`	`self._guts = guts`
`27`		`- self._offsetRange = Range(_uncheckedBounds: (0, guts.count))`
	`27`	`+ self._offsetRange = unsafe Range(_uncheckedBounds: (0, guts.count))`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`@inline(__always)`
`@@ -74,7 +74,7 @@ internal struct _StringGutsSlice {`
`74`	`74`	`._scalarAligned`
`75`	`75`	`let higher = String.Index(_encodedOffset: _offsetRange.upperBound)`
`76`	`76`	`._scalarAligned`
`77`		`- return Range(_uncheckedBounds: (lower, higher))`
	`77`	`+ return unsafe Range(_uncheckedBounds: (lower, higher))`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ extension _StringGuts {`
`80`	`80`	`_precondition(upper <= endIndex && lower <= upper,`
`81`	`81`	`"String index range is out of bounds")`
`82`	`82`
`83`		`- return Range(_uncheckedBounds: (lower, upper))`
	`83`	`+ return unsafe Range(_uncheckedBounds: (lower, upper))`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`@_alwaysEmitIntoClient`
`@@ -102,7 +102,7 @@ extension _StringGuts {`
`102`	`102`	`&& upper <= bounds.upperBound,`
`103`	`103`	`"Substring index range is out of bounds")`
`104`	`104`
`105`		`- return Range(_uncheckedBounds: (lower, upper))`
	`105`	`+ return unsafe Range(_uncheckedBounds: (lower, upper))`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`
`@@ -213,7 +213,7 @@ extension _StringGuts {`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`let r = validateSubscalarRange(range)`
`216`		`- return Range(`
	`216`	`+ return unsafe Range(`
`217`	`217`	`_uncheckedBounds: (scalarAlign(r.lowerBound), scalarAlign(r.upperBound)))`
`218`	`218`	`}`
`219`	`219`
`@@ -243,7 +243,7 @@ extension _StringGuts {`
`243`	`243`	`let r = validateSubscalarRange(range, in: bounds)`
`244`	`244`	`let upper = scalarAlign(r.upperBound)`
`245`	`245`	`let lower = scalarAlign(r.lowerBound)`
`246`		`- return Range(_uncheckedBounds: (lower, upper))`
	`246`	`+ return unsafe Range(_uncheckedBounds: (lower, upper))`
`247`	`247`	`}`
`248`	`248`	`}`
`249`	`249`
`@@ -356,7 +356,7 @@ extension _StringGuts {`
`356`	`356`	`_precondition(upper <= endIndex && lower <= upper,`
`357`	`357`	`"String index range is out of bounds")`
`358`	`358`
`359`		`- return Range(_uncheckedBounds: (lower, upper))`
	`359`	`+ return unsafe Range(_uncheckedBounds: (lower, upper))`
`360`	`360`	`}`
`361`	`361`
`362`	`362`	/// A version of `validateScalarRange` that only traps if the main executable
`@@ -377,7 +377,7 @@ extension _StringGuts {`
`377`	`377`	`}`
`378`	`378`
`379`	`379`	`let r = validateSubscalarRange_5_7(range)`
`380`		`- return Range(`
	`380`	`+ return unsafe Range(`
`381`	`381`	`_uncheckedBounds: (scalarAlign(r.lowerBound), scalarAlign(r.upperBound)))`
`382`	`382`	`}`
`383`	`383`
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,9 @@ extension StringProtocol {`
`153`	`153`	`let end = endIndex`
`154`	`154`	`_internalInvariant(`
`155`	`155`	`start.transcodedOffset == 0 && end.transcodedOffset == 0)`
`156`		`- return Range(_uncheckedBounds: (start._encodedOffset, end._encodedOffset))`
	`156`	`+ return unsafe Range(`
	`157`	`+ _uncheckedBounds: (start._encodedOffset, end._encodedOffset)`
	`158`	`+ )`
`157`	`159`	`}`
`158`	`160`	`}`
`159`	`161`