Annotate stdlib functions to get a good performance even in resilient mode, when -sil-serialize-all is disabled

This commit mostly improves the performance of arrays and ranges.
It does not cover Strings, Dictionaries and Sets yet.

Author: swiftix

benchmark/single-source/PopFrontGeneric.swift

@@ -17,6 +17,7 @@ let arrayCount = 1024
 
 // This test case exposes rdar://17440222 which caused rdar://17974483 (popFront
 // being really slow).
+@_versioned
 protocol MyArrayBufferProtocol : MutableCollection, RandomAccessCollection {
   associatedtype Element
 

stdlib/private/StdlibUnittestFoundationExtras/StdlibUnittestFoundationExtras.swift

@@ -75,6 +75,7 @@ public func autoreleasepoolIfUnoptimizedReturnAutoreleased(
 #endif
 }
 
+@_versioned
 @_silgen_name("swift_stdlib_NSArray_getObjects")
 internal func _stdlib_NSArray_getObjects(
   nsArray: AnyObject,

stdlib/public/core/Algorithm.swift

@@ -16,6 +16,7 @@
 ///   - x: A value to compare.
 ///   - y: Another value to compare.
 /// - Returns: The lesser of `x` and `y`. If `x` is equal to `y`, returns `x`.
+@_inlineable
 public func min<T : Comparable>(_ x: T, _ y: T) -> T {
   // In case `x == y` we pick `x`.
   // This preserves any pre-existing order in case `T` has identity,
@@ -33,6 +34,7 @@ public func min<T : Comparable>(_ x: T, _ y: T) -> T {
 ///   - rest: Zero or more additional values.
 /// - Returns: The least of all the arguments. If there are multiple equal
 ///   least arguments, the result is the first one.
+@_inlineable
 public func min<T : Comparable>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T {
   var minValue = min(min(x, y), z)
   // In case `value == minValue`, we pick `minValue`. See min(_:_:).
@@ -48,6 +50,7 @@ public func min<T : Comparable>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T {
 ///   - x: A value to compare.
 ///   - y: Another value to compare.
 /// - Returns: The greater of `x` and `y`. If `x` is equal to `y`, returns `y`.
+@_inlineable
 public func max<T : Comparable>(_ x: T, _ y: T) -> T {
   // In case `x == y`, we pick `y`. See min(_:_:).
   return y >= x ? y : x
@@ -62,6 +65,7 @@ public func max<T : Comparable>(_ x: T, _ y: T) -> T {
 ///   - rest: Zero or more additional values.
 /// - Returns: The greatest of all the arguments. If there are multiple equal
 ///   greatest arguments, the result is the last one.
+@_inlineable
 public func max<T : Comparable>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T {
   var maxValue = max(max(x, y), z)
   // In case `value == maxValue`, we pick `value`. See min(_:_:).
@@ -85,13 +89,18 @@ public func max<T : Comparable>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T {
 ///
 /// To create an instance of `EnumeratedIterator`, call
 /// `enumerated().makeIterator()` on a sequence or collection.
+@_fixed_layout
 public struct EnumeratedIterator<
   Base : IteratorProtocol
 > : IteratorProtocol, Sequence {
+  @_versioned
   internal var _base: Base
+  @_versioned
   internal var _count: Int
 
   /// Construct from a `Base` iterator.
+  @_inlineable
+  @_versioned
   internal init(_base: Base) {
     self._base = _base
     self._count = 0
@@ -104,6 +113,7 @@ public struct EnumeratedIterator<
   /// exists.
   ///
   /// Once `nil` has been returned, all subsequent calls return `nil`.
+  @_inlineable
   public mutating func next() -> Element? {
     guard let b = _base.next() else { return nil }
     let result = (offset: _count, element: b)
@@ -128,15 +138,20 @@ public struct EnumeratedIterator<
 ///     }
 ///     // Prints "0: foo"
 ///     // Prints "1: bar"
+@_fixed_layout
 public struct EnumeratedSequence<Base : Sequence> : Sequence {
+  @_versioned
   internal var _base: Base
 
   /// Construct from a `Base` sequence.
+  @_inlineable
+  @_versioned
   internal init(_base: Base) {
     self._base = _base
   }
 
   /// Returns an iterator over the elements of this sequence.
+  @_inlineable
   public func makeIterator() -> EnumeratedIterator<Base.Iterator> {
     return EnumeratedIterator(_base: _base.makeIterator())
   }

stdlib/public/core/ArrayBody.swift

@@ -17,10 +17,13 @@
 
 import SwiftShims
 
+@_fixed_layout
 @_versioned
 internal struct _ArrayBody {
+  @_versioned
   var _storage: _SwiftArrayBodyStorage
 
+  @_inlineable
   @_versioned
   init(count: Int, capacity: Int, elementTypeIsBridgedVerbatim: Bool = false) {
     _sanityCheck(count >= 0)
@@ -36,11 +39,15 @@ internal struct _ArrayBody {
   /// constructed, but since we want to claim all the allocated
   /// capacity after a new buffer is allocated, it's typical to want
   /// to update it immediately after construction.
+  @_inlineable
+  @_versioned
   init() {
     _storage = _SwiftArrayBodyStorage(count: 0, _capacityAndFlags: 0)
   }
 
   /// The number of elements stored in this Array.
+  @_inlineable
+  @_versioned
   var count: Int {
     get {
       return _assumeNonNegative(_storage.count)
@@ -52,6 +59,8 @@ internal struct _ArrayBody {
 
   /// The number of elements that can be stored in this Array without
   /// reallocation.
+  @_inlineable
+  @_versioned
   var capacity: Int {
     return Int(_capacityAndFlags >> 1)
   }
@@ -62,6 +71,8 @@ internal struct _ArrayBody {
   /// optimizer before 1.0 ships, so we store it in a bit here to
   /// avoid the cost of calls into the runtime that compute the
   /// answer.
+  @_inlineable
+  @_versioned
   var elementTypeIsBridgedVerbatim: Bool {
     get {
       return (_capacityAndFlags & 0x1) != 0
@@ -74,6 +85,8 @@ internal struct _ArrayBody {
 
   /// Storage optimization: compresses capacity and
   /// elementTypeIsBridgedVerbatim together.
+  @_inlineable
+  @_versioned
   var _capacityAndFlags: UInt {
     get {
       return _storage._capacityAndFlags