---

yaml
---
r: 345822
b: refs/heads/master
c: 2af3959
h: refs/heads/master

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a604b678b2ff7ec822ea758ca431d64ddf8227e0
+refs/heads/master: 2af3959253dafe2030451be22017d21c2871b8a7
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/stdlib/public/core/ContiguousArrayBuffer.swift

@@ -71,13 +71,13 @@ internal var _emptyArrayStorage : __EmptyArrayStorage {
 }
 
 // The class that implements the storage for a ContiguousArray<Element>
-@_fixed_layout // FIXME(sil-serialize-all)
+@_fixed_layout
 @usableFromInline
 internal final class _ContiguousArrayStorage<
   Element
 > : __ContiguousArrayStorageBase {
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   deinit {
     _elementPointer.deinitialize(count: countAndCapacity.count)
     _fixLifetime(self)
@@ -654,7 +654,7 @@ internal struct _UnsafePartiallyInitializedContiguousArrayBuffer<Element> {
 
   /// Initialize the buffer with an initial size of `initialCapacity`
   /// elements.
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   @inline(__always) // For performance reasons.
   internal init(initialCapacity: Int) {
     if initialCapacity == 0 {
@@ -670,7 +670,7 @@ internal struct _UnsafePartiallyInitializedContiguousArrayBuffer<Element> {
   }
 
   /// Add an element to the buffer, reallocating if necessary.
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   @inline(__always) // For performance reasons.
   internal mutating func add(_ element: Element) {
     if remainingCapacity == 0 {
@@ -693,7 +693,7 @@ internal struct _UnsafePartiallyInitializedContiguousArrayBuffer<Element> {
   }
 
   /// Add an element to the buffer, which must have remaining capacity.
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   @inline(__always) // For performance reasons.
   internal mutating func addWithExistingCapacity(_ element: Element) {
     _sanityCheck(remainingCapacity > 0,
@@ -709,7 +709,7 @@ internal struct _UnsafePartiallyInitializedContiguousArrayBuffer<Element> {
   ///
   /// Returns the fully-initialized buffer. `self` is reset to contain an
   /// empty buffer and cannot be used afterward.
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   @inline(__always) // For performance reasons.
   internal mutating func finish() -> ContiguousArray<Element> {
     // Adjust the initialized count of the buffer.
@@ -724,7 +724,7 @@ internal struct _UnsafePartiallyInitializedContiguousArrayBuffer<Element> {
   ///
   /// Returns the fully-initialized buffer. `self` is reset to contain an
   /// empty buffer and cannot be used afterward.
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   @inline(__always) // For performance reasons.
   internal mutating func finishWithOriginalCount() -> ContiguousArray<Element> {
     _sanityCheck(remainingCapacity == result.capacity - result.count,

trunk/stdlib/public/core/SliceBuffer.swift

@@ -64,19 +64,19 @@ internal struct _SliceBuffer<Element>
     }
   }
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal var _hasNativeBuffer: Bool {
     return (endIndexAndFlags & 1) != 0
   }
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal var nativeBuffer: NativeBuffer {
     _sanityCheck(_hasNativeBuffer)
     return NativeBuffer(
       owner as? __ContiguousArrayStorageBase ?? _emptyArrayStorage)
   }
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal var nativeOwner: AnyObject {
     _sanityCheck(_hasNativeBuffer, "Expect a native array")
     return owner
@@ -88,7 +88,7 @@ internal struct _SliceBuffer<Element>
   /// - Precondition: This buffer is backed by a uniquely-referenced
   ///   `_ContiguousArrayBuffer` and
   ///   `insertCount <= numericCast(newValues.count)`.
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal mutating func replaceSubrange<C>(
     _ subrange: Range<Int>,
     with insertCount: Int,
@@ -125,7 +125,7 @@ internal struct _SliceBuffer<Element>
   /// A value that identifies the storage used by the buffer.  Two
   /// buffers address the same elements when they have the same
   /// identity and count.
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal var identity: UnsafeRawPointer {
     return UnsafeRawPointer(firstElementAddress)
   }
@@ -136,12 +136,12 @@ internal struct _SliceBuffer<Element>
   @usableFromInline
   internal let subscriptBaseAddress: UnsafeMutablePointer<Element>
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal var firstElementAddress: UnsafeMutablePointer<Element> {
     return subscriptBaseAddress + startIndex
   }
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal var firstElementAddressIfContiguous: UnsafeMutablePointer<Element>? {
     return firstElementAddress
   }
@@ -152,7 +152,7 @@ internal struct _SliceBuffer<Element>
 
   //===--- Non-essential bits ---------------------------------------------===//
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal mutating func requestUniqueMutableBackingBuffer(
     minimumCapacity: Int
   ) -> NativeBuffer? {
@@ -210,7 +210,7 @@ internal struct _SliceBuffer<Element>
   /// If this buffer is backed by a `_ContiguousArrayBuffer`
   /// containing the same number of elements as `self`, return it.
   /// Otherwise, return `nil`.
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal func requestNativeBuffer() -> _ContiguousArrayBuffer<Element>? {
     _invariantCheck()
     if _fastPath(_hasNativeBuffer && nativeBuffer.count == count) {
@@ -219,7 +219,7 @@ internal struct _SliceBuffer<Element>
     return nil
   }
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   @discardableResult
   internal __consuming func _copyContents(
     subRange bounds: Range<Int>,
@@ -235,12 +235,12 @@ internal struct _SliceBuffer<Element>
   }
 
   /// True, if the array is native and does not need a deferred type check.
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal var arrayPropertyIsNativeTypeChecked: Bool {
     return _hasNativeBuffer
   }
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal var count: Int {
     get {
       return endIndex - startIndex
@@ -257,13 +257,13 @@ internal struct _SliceBuffer<Element>
 
   /// Traps unless the given `index` is valid for subscripting, i.e.
   /// `startIndex ≤ index < endIndex`
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal func _checkValidSubscript(_ index : Int) {
     _precondition(
       index >= startIndex && index < endIndex, "Index out of bounds")
   }
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal var capacity: Int {
     let count = self.count
     if _slowPath(!_hasNativeBuffer) {
@@ -277,12 +277,12 @@ internal struct _SliceBuffer<Element>
     return count
   }
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal mutating func isUniquelyReferenced() -> Bool {
     return isKnownUniquelyReferenced(&owner)
   }
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal func getElement(_ i: Int) -> Element {
     _sanityCheck(i >= startIndex, "slice index is out of range (before startIndex)")
     _sanityCheck(i < endIndex, "slice index is out of range")
@@ -293,7 +293,7 @@ internal struct _SliceBuffer<Element>
   ///
   /// - Precondition: `position` is a valid position in `self` and
   ///   `position != endIndex`.
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal subscript(position: Int) -> Element {
     get {
       return getElement(position)
@@ -305,7 +305,7 @@ internal struct _SliceBuffer<Element>
     }
   }
 
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal subscript(bounds: Range<Int>) -> _SliceBuffer {
     get {
       _sanityCheck(bounds.lowerBound >= startIndex)
@@ -334,7 +334,7 @@ internal struct _SliceBuffer<Element>
   ///
   /// `endIndex` is always reachable from `startIndex` by zero or more
   /// applications of `index(after:)`.
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal var endIndex: Int {
     get {
       return Int(endIndexAndFlags >> 1)
@@ -371,7 +371,7 @@ internal struct _SliceBuffer<Element>
 }
 
 extension _SliceBuffer {
-  @inlinable // FIXME(sil-serialize-all)
+  @inlinable
   internal __consuming func _copyToContiguousArray() -> ContiguousArray<Element> {
     if _hasNativeBuffer {
       let n = nativeBuffer