Merge pull request #2334 from swiftwasm/main

pull[bot] · web-flow · commit 570c22c3e528 · 2020-12-13T09:46:19.000Z
[pull] swiftwasm from main
diff --git a/lib/Driver/Compilation.cpp b/lib/Driver/Compilation.cpp
@@ -1802,8 +1802,11 @@ namespace driver {
 
     fine_grained_dependencies::ModuleDepGraph &&
     takeFineGrainedDepGraph(const bool forRanges) && {
-      return forRanges ? std::move(FineGrainedDepGraphForRanges)
-                       : std::move(FineGrainedDepGraph);
+      if (forRanges) {
+        return std::move(FineGrainedDepGraphForRanges);
+      } else {
+        return std::move(FineGrainedDepGraph);
+      }
     }
   };
 } // namespace driver
diff --git a/lib/Frontend/ArgsToFrontendOutputsConverter.cpp b/lib/Frontend/ArgsToFrontendOutputsConverter.cpp
@@ -354,6 +354,15 @@ SupplementaryOutputPathsComputer::getSupplementaryFilenamesFromArguments(
 
   if (paths.size() == N)
     return paths;
+  else if (pathID == options::OPT_emit_loaded_module_trace_path &&
+           paths.size() < N) {
+    // We only need one file to output the module trace file because they
+    // are all equivalent. Add additional empty output paths for module trace to
+    // make sure the compiler won't panic for diag::error_wrong_number_of_arguments.
+    for(unsigned I = paths.size(); I != N; I ++)
+      paths.emplace_back();
+    return paths;
+  }
 
   if (paths.empty())
     return std::vector<std::string>(N, std::string());
diff --git a/stdlib/public/Concurrency/Task.cpp b/stdlib/public/Concurrency/Task.cpp
@@ -22,11 +22,6 @@
 #include "TaskPrivate.h"
 #include "AsyncCall.h"
 
-#if defined(__APPLE__)
-// TODO: We shouldn't need this
-#include <dispatch/dispatch.h>
-#endif
-
 using namespace swift;
 using FutureFragment = AsyncTask::FutureFragment;
 
@@ -509,23 +504,9 @@ struct AsyncContinuationContext {
 
 static void resumeTaskAfterContinuation(AsyncTask *task,
                                         AsyncContinuationContext *context) {
-#if __APPLE__
-  // TODO: Enqueue the task on the specific executor in the continuation
-  // context.
-  //
-  // For now, just enqueue the task resumption on the global concurrent queue
-  // so that we're able to return back to the caller of resume.
-  
-  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
-                 ^{
-                  task->run(context->ResumeExecutor);
-                 });
-#else
-  swift_unreachable("not implemented");
-#endif
+  swift_task_enqueue(task, context->ResumeExecutor);
 }
 
-
 }
 
 SWIFT_CC(swift)
diff --git a/stdlib/public/Concurrency/Task.swift b/stdlib/public/Concurrency/Task.swift
@@ -412,11 +412,11 @@ public func _runChildTask<T>(operation: @escaping () async throws -> T) async
 @_alwaysEmitIntoClient
 @usableFromInline
 internal func _runTaskForBridgedAsyncMethod(_ body: @escaping () async -> Void) {
-  // TODO: As a start, we should invoke Task.runDetached here, but we
-  // can probably do better if we're already running on behalf of a task,
+  // TODO: We can probably do better than Task.runDetached
+  // if we're already running on behalf of a task,
   // if the receiver of the method invocation is itself an Actor, or in other
   // situations.
-  fatalError("not implemented")
+  _ = Task.runDetached { await body() }
 }
 
 #endif
diff --git a/stdlib/public/SwiftShims/LibcShims.h b/stdlib/public/SwiftShims/LibcShims.h
@@ -129,7 +129,12 @@ float _stdlib_remainderf(float _self, float _other) {
   
 static inline SWIFT_ALWAYS_INLINE
 float _stdlib_squareRootf(float _self) {
+#if defined(_WIN32) && (defined(_M_IX86) || defined(__i386__))
+  typedef float __m128 __attribute__((__vector_size__(16), __aligned__(16)));
+  return __builtin_ia32_sqrtss(__extension__ (__m128){ _self, 0, 0, 0 })[0];
+#else
   return __builtin_sqrtf(_self);
+#endif
 }
 
 static inline SWIFT_ALWAYS_INLINE
diff --git a/stdlib/public/core/ClosedRange.swift b/stdlib/public/core/ClosedRange.swift
@@ -68,6 +68,14 @@ public struct ClosedRange<Bound: Comparable> {
   /// The range's upper bound.
   public let upperBound: Bound
 
+  // This works around _debugPrecondition() impacting the performance of
+  // optimized code. (rdar://72246338)
+  @_alwaysEmitIntoClient @inline(__always)
+  internal init(_uncheckedBounds bounds: (lower: Bound, upper: Bound)) {
+    self.lowerBound = bounds.lower
+    self.upperBound = bounds.upper
+  }
+
   /// Creates an instance with the given bounds.
   ///
   /// Because this initializer does not perform any checks, it should be used
@@ -78,8 +86,9 @@ public struct ClosedRange<Bound: Comparable> {
   /// - Parameter bounds: A tuple of the lower and upper bounds of the range.
   @inlinable
   public init(uncheckedBounds bounds: (lower: Bound, upper: Bound)) {
-    self.lowerBound = bounds.lower
-    self.upperBound = bounds.upper
+    _debugPrecondition(bounds.lower <= bounds.upper,
+      "ClosedRange requires lowerBound <= upperBound")
+    self.init(_uncheckedBounds: (lower: bounds.lower, upper: bounds.upper))
   }
 }
 
@@ -100,8 +109,9 @@ extension ClosedRange: RangeExpression {
   public func relative<C: Collection>(to collection: C) -> Range<Bound>
   where C.Index == Bound {
     return Range(
-      uncheckedBounds: (
-        lower: lowerBound, upper: collection.index(after: self.upperBound)))
+      _uncheckedBounds: (
+        lower: lowerBound,
+        upper: collection.index(after: self.upperBound)))
   }
 
   /// Returns a Boolean value indicating whether the given element is contained
@@ -336,7 +346,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 ClosedRange(_uncheckedBounds: (lower: minimum, upper: maximum))
   }
 }
 
@@ -423,7 +433,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 ClosedRange(_uncheckedBounds: (lower: lower, upper: upper))
   }
 }
 
@@ -439,7 +449,7 @@ 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))
+    self.init(_uncheckedBounds: (lower: other.lowerBound, upper: upperBound))
   }
 }
 
@@ -476,7 +486,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))
+    self.init(_uncheckedBounds: (lower: lowerBound, upper: upperBound))
   }
 }
 
diff --git a/stdlib/public/core/Range.swift b/stdlib/public/core/Range.swift
@@ -157,6 +157,14 @@ public struct Range<Bound: Comparable> {
   /// instance does not contain its upper bound.
   public let upperBound: Bound
 
+  // This works around _debugPrecondition() impacting the performance of
+  // optimized code. (rdar://72246338)
+  @_alwaysEmitIntoClient @inline(__always)
+  internal init(_uncheckedBounds bounds: (lower: Bound, upper: Bound)) {
+    self.lowerBound = bounds.lower
+    self.upperBound = bounds.upper
+  }
+
   /// Creates an instance with the given bounds.
   ///
   /// Because this initializer does not perform any checks, it should be used
@@ -167,8 +175,9 @@ public struct Range<Bound: Comparable> {
   /// - Parameter bounds: A tuple of the lower and upper bounds of the range.
   @inlinable
   public init(uncheckedBounds bounds: (lower: Bound, upper: Bound)) {
-    self.lowerBound = bounds.lower
-    self.upperBound = bounds.upper
+    _debugPrecondition(bounds.lower <= bounds.upper,
+      "Range requires lowerBound <= upperBound")
+    self.init(_uncheckedBounds: (lower: bounds.lower, upper: bounds.upper))
   }
 
   /// Returns a Boolean value indicating whether the given element is contained
@@ -308,7 +317,7 @@ extension Range where Bound: Strideable, Bound.Stride: SignedInteger {
   /// require an upper bound of `Int.max + 1`, which is not representable as
   public init(_ other: ClosedRange<Bound>) {
     let upperBound = other.upperBound.advanced(by: 1)
-    self.init(uncheckedBounds: (lower: other.lowerBound, upper: upperBound))
+    self.init(_uncheckedBounds: (lower: other.lowerBound, upper: upperBound))
   }
 }
 
@@ -325,7 +334,7 @@ extension Range: RangeExpression {
   @inlinable // trivial-implementation
   public func relative<C: Collection>(to collection: C) -> Range<Bound>
   where C.Index == Bound {
-    return Range(uncheckedBounds: (lower: lowerBound, upper: upperBound))
+    self
   }
 }
 
@@ -359,7 +368,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 Range(_uncheckedBounds: (lower: lower, upper: upper))
   }
 }
 
@@ -435,7 +444,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))
+    self.init(_uncheckedBounds: (lower: lowerBound, upper: upperBound))
   }
 }
 
@@ -729,7 +738,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 Range(_uncheckedBounds: (lower: minimum, upper: maximum))
   }
 
   /// Returns a partial range up to, but not including, its upper bound.
diff --git a/stdlib/public/core/SmallString.swift b/stdlib/public/core/SmallString.swift
@@ -208,7 +208,7 @@ extension _SmallString {
         // Restore the memory type of self._storage
         _ = rawPtr.bindMemory(to: RawBitPattern.self, capacity: 1)
       }
-      return try f(UnsafeBufferPointer(start: ptr, count: count))
+      return try f(UnsafeBufferPointer(_uncheckedStart: ptr, count: count))
     }
   }
 
diff --git a/stdlib/public/core/String.swift b/stdlib/public/core/String.swift
@@ -458,6 +458,7 @@ extension String {
       contigBytes._providesContiguousBytesNoCopy
     {
       self = contigBytes.withUnsafeBytes { rawBufPtr in
+        Builtin.onFastPath() // encourage SIL Optimizer to inline this closure
         return String._fromUTF8Repairing(
           UnsafeBufferPointer(
             start: rawBufPtr.baseAddress?.assumingMemoryBound(to: UInt8.self),
diff --git a/stdlib/public/core/StringObject.swift b/stdlib/public/core/StringObject.swift
@@ -902,7 +902,7 @@ extension _StringObject {
       return sharedUTF8
     }
     return UnsafeBufferPointer(
-      start: self.nativeUTF8Start, count: self.largeCount)
+      _uncheckedStart: self.nativeUTF8Start, count: self.largeCount)
   }
 
   // Whether the object stored can be bridged directly as a NSString
diff --git a/stdlib/public/core/StringProtocol.swift b/stdlib/public/core/StringProtocol.swift
@@ -153,7 +153,7 @@ extension StringProtocol {
       let end = endIndex
       _internalInvariant(
         start.transcodedOffset == 0 && end.transcodedOffset == 0)
-      return Range(uncheckedBounds: (start._encodedOffset, end._encodedOffset))
+      return Range(_uncheckedBounds: (start._encodedOffset, end._encodedOffset))
     }
   }
 
diff --git a/stdlib/public/core/StringStorageBridge.swift b/stdlib/public/core/StringStorageBridge.swift
@@ -30,7 +30,7 @@ extension _AbstractStringStorage {
                   "Range out of bounds")
 
     let range = Range(
-      uncheckedBounds: (aRange.location, aRange.location+aRange.length))
+      _uncheckedBounds: (aRange.location, aRange.location+aRange.length))
     let str = asString
     str._copyUTF16CodeUnits(
       into: UnsafeMutableBufferPointer(start: buffer, count: range.count),
diff --git a/stdlib/public/core/Substring.swift b/stdlib/public/core/Substring.swift
@@ -105,7 +105,7 @@ public struct Substring {
 
     self._slice = Slice(
       base: slice.base,
-      bounds: Range(uncheckedBounds: (start, end)))
+      bounds: Range(_uncheckedBounds: (start, end)))
     _invariantCheck()
   }
 
@@ -132,7 +132,7 @@ extension Substring {
   @inlinable @inline(__always)
   internal var _offsetRange: Range<Int> {
     return Range(
-      uncheckedBounds: (startIndex._encodedOffset, endIndex._encodedOffset))
+      _uncheckedBounds: (startIndex._encodedOffset, endIndex._encodedOffset))
   }
 
   #if !INTERNAL_CHECKS_ENABLED
@@ -322,7 +322,8 @@ extension Substring: CustomDebugStringConvertible {
 
 extension Substring: LosslessStringConvertible {
   public init(_ content: String) {
-    self = content[...]
+    let range = Range(_uncheckedBounds: (content.startIndex, content.endIndex))
+    self.init(Slice(base: content, bounds: range))
   }
 }
 
@@ -727,14 +728,14 @@ extension Substring: RangeReplaceableCollection {
   public init<S: Sequence>(_ elements: S)
   where S.Element == Character {
     if let str = elements as? String {
-      self = str[...]
+      self.init(str)
       return
     }
     if let subStr = elements as? Substring {
       self = subStr
       return
     }
-    self = String(elements)[...]
+    self.init(String(elements))
   }
 
   @inlinable // specialize
diff --git a/stdlib/public/core/UnsafeBufferPointer.swift.gyb b/stdlib/public/core/UnsafeBufferPointer.swift.gyb
@@ -207,7 +207,14 @@ extension Unsafe${Mutable}BufferPointer: ${Mutable}Collection, RandomAccessColle
     // optimizer is not capable of creating partial specializations yet.
     // NOTE: Range checks are not performed here, because it is done later by
     // the subscript function.
-    return end - start
+    // NOTE: We allow the subtraction to silently overflow in release builds
+    // to eliminate a superflous check when `start` and `end` are both valid
+    // indices. (The operation can only overflow if `start` is negative, which
+    // implies it's an invalid index.) `Collection` does not specify what
+    // `distance` should return when given an invalid index pair.
+    let result = end.subtractingReportingOverflow(start)
+    _debugPrecondition(!result.overflow)
+    return result.partialValue
   }
 
   @inlinable // unsafe-performance
@@ -387,6 +394,17 @@ extension Unsafe${Mutable}BufferPointer: ${Mutable}Collection, RandomAccessColle
 }
 
 extension Unsafe${Mutable}BufferPointer {
+  // This works around _debugPrecondition() impacting the performance of
+  // optimized code. (rdar://72246338)
+  @_alwaysEmitIntoClient
+  internal init(
+    @_nonEphemeral _uncheckedStart start: Unsafe${Mutable}Pointer<Element>?,
+    count: Int
+  ) {
+    _position = start
+    self.count = count
+  }
+
   /// Creates a new buffer pointer over the specified number of contiguous
   /// instances beginning at the given pointer.
   ///
@@ -401,13 +419,12 @@ extension Unsafe${Mutable}BufferPointer {
   public init(
     @_nonEphemeral start: Unsafe${Mutable}Pointer<Element>?, count: Int
   ) {
-    _precondition(
+    _debugPrecondition(
       count >= 0, "Unsafe${Mutable}BufferPointer with negative count")
-    _precondition(
+    _debugPrecondition(
       count == 0 || start != nil,
       "Unsafe${Mutable}BufferPointer has a nil start and nonzero count")
-    _position = start
-    self.count = count
+    self.init(_uncheckedStart: start, count: _assumeNonNegative(count))
   }
 
   @inlinable // unsafe-performance
@@ -498,6 +515,17 @@ extension Unsafe${Mutable}BufferPointer {
   /// - Parameter slice: The buffer slice to rebase.
   @inlinable // unsafe-performance
   public init(rebasing slice: Slice<UnsafeBufferPointer<Element>>) {
+    // NOTE: `Slice` does not guarantee that its start/end indices are valid
+    // in `base` -- it merely ensures that `startIndex <= endIndex`.
+    // We need manually check that we aren't given an invalid slice,
+    // or the resulting collection would allow access that was
+    // out-of-bounds with respect to the original base buffer.
+    // We only do this in debug builds to prevent a measurable performance
+    // degradation wrt passing around pointers not wrapped in a BufferPointer
+    // construct.
+    _debugPrecondition(
+      slice.startIndex >= 0 && slice.endIndex <= slice.base.count,
+      "Invalid slice")
     let base = slice.base.baseAddress?.advanced(by: slice.startIndex)
     let count = slice.endIndex &- slice.startIndex
     self.init(start: base, count: count)
diff --git a/stdlib/public/core/UnsafeRawBufferPointer.swift.gyb b/stdlib/public/core/UnsafeRawBufferPointer.swift.gyb
diff --git a/test/Frontend/batch_mode_missing_module_trace_output.swift b/test/Frontend/batch_mode_missing_module_trace_output.swift
diff --git a/test/stdlib/RangeTraps.swift b/test/stdlib/RangeTraps.swift
diff --git a/validation-test/stdlib/ArrayTraps.swift.gyb b/validation-test/stdlib/ArrayTraps.swift.gyb
diff --git a/validation-test/stdlib/Range.swift.gyb b/validation-test/stdlib/Range.swift.gyb

Original file line number	Diff line number	Diff line change
`@@ -68,6 +68,14 @@ public struct ClosedRange<Bound: Comparable> {`
`68`	`68`	`/// The range's upper bound.`
`69`	`69`	`public let upperBound: Bound`
`70`	`70`
	`71`	`+ // This works around _debugPrecondition() impacting the performance of`
	`72`	`+ // optimized code. (rdar://72246338)`
	`73`	`+ @_alwaysEmitIntoClient @inline(__always)`
	`74`	`+ internal init(_uncheckedBounds bounds: (lower: Bound, upper: Bound)) {`
	`75`	`+ self.lowerBound = bounds.lower`
	`76`	`+ self.upperBound = bounds.upper`
	`77`	`+ }`
	`78`	`+`
`71`	`79`	`/// Creates an instance with the given bounds.`
`72`	`80`	`///`
`73`	`81`	`/// Because this initializer does not perform any checks, it should be used`
`@@ -78,8 +86,9 @@ public struct ClosedRange<Bound: Comparable> {`
`78`	`86`	`/// - Parameter bounds: A tuple of the lower and upper bounds of the range.`
`79`	`87`	`@inlinable`
`80`	`88`	`public init(uncheckedBounds bounds: (lower: Bound, upper: Bound)) {`
`81`		`- self.lowerBound = bounds.lower`
`82`		`- self.upperBound = bounds.upper`
	`89`	`+ _debugPrecondition(bounds.lower <= bounds.upper,`
	`90`	`+ "ClosedRange requires lowerBound <= upperBound")`
	`91`	`+ self.init(_uncheckedBounds: (lower: bounds.lower, upper: bounds.upper))`
`83`	`92`	`}`
`84`	`93`	`}`
`85`	`94`
`@@ -100,8 +109,9 @@ extension ClosedRange: RangeExpression {`
`100`	`109`	`public func relative<C: Collection>(to collection: C) -> Range<Bound>`
`101`	`110`	`where C.Index == Bound {`
`102`	`111`	`return Range(`
`103`		`- uncheckedBounds: (`
`104`		`- lower: lowerBound, upper: collection.index(after: self.upperBound)))`
	`112`	`+ _uncheckedBounds: (`
	`113`	`+ lower: lowerBound,`
	`114`	`+ upper: collection.index(after: self.upperBound)))`
`105`	`115`	`}`
`106`	`116`
`107`	`117`	`/// Returns a Boolean value indicating whether the given element is contained`
`@@ -336,7 +346,7 @@ extension Comparable {`
`336`	`346`	`public static func ... (minimum: Self, maximum: Self) -> ClosedRange<Self> {`
`337`	`347`	`_precondition(`
`338`	`348`	`minimum <= maximum, "Range requires lowerBound <= upperBound")`
`339`		`- return ClosedRange(uncheckedBounds: (lower: minimum, upper: maximum))`
	`349`	`+ return ClosedRange(_uncheckedBounds: (lower: minimum, upper: maximum))`
`340`	`350`	`}`
`341`	`351`	`}`
`342`	`352`
`@@ -423,7 +433,7 @@ extension ClosedRange {`
`423`	`433`	`limits.upperBound < self.upperBound ? limits.upperBound`
`424`	`434`	`: limits.lowerBound > self.upperBound ? limits.lowerBound`
`425`	`435`	`: self.upperBound`
`426`		`- return ClosedRange(uncheckedBounds: (lower: lower, upper: upper))`
	`436`	`+ return ClosedRange(_uncheckedBounds: (lower: lower, upper: upper))`
`427`	`437`	`}`
`428`	`438`	`}`
`429`	`439`
`@@ -439,7 +449,7 @@ extension ClosedRange where Bound: Strideable, Bound.Stride: SignedInteger {`
`439`	`449`	`public init(_ other: Range<Bound>) {`
`440`	`450`	`_precondition(!other.isEmpty, "Can't form an empty closed range")`
`441`	`451`	`let upperBound = other.upperBound.advanced(by: -1)`
`442`		`- self.init(uncheckedBounds: (lower: other.lowerBound, upper: upperBound))`
	`452`	`+ self.init(_uncheckedBounds: (lower: other.lowerBound, upper: upperBound))`
`443`	`453`	`}`
`444`	`454`	`}`
`445`	`455`
`@@ -476,7 +486,7 @@ extension ClosedRange: Decodable where Bound: Decodable {`
`476`	`486`	`codingPath: decoder.codingPath,`
`477`	`487`	`debugDescription: "Cannot initialize \(ClosedRange.self) with a lowerBound (\(lowerBound)) greater than upperBound (\(upperBound))"))`
`478`	`488`	`}`
`479`		`- self.init(uncheckedBounds: (lower: lowerBound, upper: upperBound))`
	`489`	`+ self.init(_uncheckedBounds: (lower: lowerBound, upper: upperBound))`
`480`	`490`	`}`
`481`	`491`	`}`
`482`	`492`
Original file line number	Diff line number	Diff line change
`@@ -157,6 +157,14 @@ public struct Range<Bound: Comparable> {`
`157`	`157`	`/// instance does not contain its upper bound.`
`158`	`158`	`public let upperBound: Bound`
`159`	`159`
	`160`	`+ // This works around _debugPrecondition() impacting the performance of`
	`161`	`+ // optimized code. (rdar://72246338)`
	`162`	`+ @_alwaysEmitIntoClient @inline(__always)`
	`163`	`+ internal init(_uncheckedBounds bounds: (lower: Bound, upper: Bound)) {`
	`164`	`+ self.lowerBound = bounds.lower`
	`165`	`+ self.upperBound = bounds.upper`
	`166`	`+ }`
	`167`	`+`
`160`	`168`	`/// Creates an instance with the given bounds.`
`161`	`169`	`///`
`162`	`170`	`/// Because this initializer does not perform any checks, it should be used`
`@@ -167,8 +175,9 @@ public struct Range<Bound: Comparable> {`
`167`	`175`	`/// - Parameter bounds: A tuple of the lower and upper bounds of the range.`
`168`	`176`	`@inlinable`
`169`	`177`	`public init(uncheckedBounds bounds: (lower: Bound, upper: Bound)) {`
`170`		`- self.lowerBound = bounds.lower`
`171`		`- self.upperBound = bounds.upper`
	`178`	`+ _debugPrecondition(bounds.lower <= bounds.upper,`
	`179`	`+ "Range requires lowerBound <= upperBound")`
	`180`	`+ self.init(_uncheckedBounds: (lower: bounds.lower, upper: bounds.upper))`
`172`	`181`	`}`
`173`	`182`
`174`	`183`	`/// Returns a Boolean value indicating whether the given element is contained`
`@@ -308,7 +317,7 @@ extension Range where Bound: Strideable, Bound.Stride: SignedInteger {`
`308`	`317`	/// require an upper bound of `Int.max + 1`, which is not representable as
`309`	`318`	`public init(_ other: ClosedRange<Bound>) {`
`310`	`319`	`let upperBound = other.upperBound.advanced(by: 1)`
`311`		`- self.init(uncheckedBounds: (lower: other.lowerBound, upper: upperBound))`
	`320`	`+ self.init(_uncheckedBounds: (lower: other.lowerBound, upper: upperBound))`
`312`	`321`	`}`
`313`	`322`	`}`
`314`	`323`
`@@ -325,7 +334,7 @@ extension Range: RangeExpression {`
`325`	`334`	`@inlinable // trivial-implementation`
`326`	`335`	`public func relative<C: Collection>(to collection: C) -> Range<Bound>`
`327`	`336`	`where C.Index == Bound {`
`328`		`- return Range(uncheckedBounds: (lower: lowerBound, upper: upperBound))`
	`337`	`+ self`
`329`	`338`	`}`
`330`	`339`	`}`
`331`	`340`
`@@ -359,7 +368,7 @@ extension Range {`
`359`	`368`	`limits.upperBound < self.upperBound ? limits.upperBound`
`360`	`369`	`: limits.lowerBound > self.upperBound ? limits.lowerBound`
`361`	`370`	`: self.upperBound`
`362`		`- return Range(uncheckedBounds: (lower: lower, upper: upper))`
	`371`	`+ return Range(_uncheckedBounds: (lower: lower, upper: upper))`
`363`	`372`	`}`
`364`	`373`	`}`
`365`	`374`
`@@ -435,7 +444,7 @@ extension Range: Decodable where Bound: Decodable {`
`435`	`444`	`codingPath: decoder.codingPath,`
`436`	`445`	`debugDescription: "Cannot initialize \(Range.self) with a lowerBound (\(lowerBound)) greater than upperBound (\(upperBound))"))`
`437`	`446`	`}`
`438`		`- self.init(uncheckedBounds: (lower: lowerBound, upper: upperBound))`
	`447`	`+ self.init(_uncheckedBounds: (lower: lowerBound, upper: upperBound))`
`439`	`448`	`}`
`440`	`449`	`}`
`441`	`450`
`@@ -729,7 +738,7 @@ extension Comparable {`
`729`	`738`	`public static func ..< (minimum: Self, maximum: Self) -> Range<Self> {`
`730`	`739`	`_precondition(minimum <= maximum,`
`731`	`740`	`"Range requires lowerBound <= upperBound")`
`732`		`- return Range(uncheckedBounds: (lower: minimum, upper: maximum))`
	`741`	`+ return Range(_uncheckedBounds: (lower: minimum, upper: maximum))`
`733`	`742`	`}`
`734`	`743`
`735`	`744`	`/// Returns a partial range up to, but not including, its upper bound.`
Original file line number	Diff line number	Diff line change
`@@ -208,7 +208,7 @@ extension _SmallString {`
`208`	`208`	`// Restore the memory type of self._storage`
`209`	`209`	`_ = rawPtr.bindMemory(to: RawBitPattern.self, capacity: 1)`
`210`	`210`	`}`
`211`		`- return try f(UnsafeBufferPointer(start: ptr, count: count))`
	`211`	`+ return try f(UnsafeBufferPointer(_uncheckedStart: ptr, count: count))`
`212`	`212`	`}`
`213`	`213`	`}`
`214`	`214`
Original file line number	Diff line number	Diff line change
`@@ -458,6 +458,7 @@ extension String {`
`458`	`458`	`contigBytes._providesContiguousBytesNoCopy`
`459`	`459`	`{`
`460`	`460`	`self = contigBytes.withUnsafeBytes { rawBufPtr in`
	`461`	`+ Builtin.onFastPath() // encourage SIL Optimizer to inline this closure`
`461`	`462`	`return String._fromUTF8Repairing(`
`462`	`463`	`UnsafeBufferPointer(`
`463`	`464`	`start: rawBufPtr.baseAddress?.assumingMemoryBound(to: UInt8.self),`
Original file line number	Diff line number	Diff line change
`@@ -902,7 +902,7 @@ extension _StringObject {`
`902`	`902`	`return sharedUTF8`
`903`	`903`	`}`
`904`	`904`	`return UnsafeBufferPointer(`
`905`		`- start: self.nativeUTF8Start, count: self.largeCount)`
	`905`	`+ _uncheckedStart: self.nativeUTF8Start, count: self.largeCount)`
`906`	`906`	`}`
`907`	`907`
`908`	`908`	`// Whether the object stored can be bridged directly as a NSString`