[stdlib] Constrain BinaryInteger.Words to be a Collection

stdlib/public/core/Collection.swift

@@ -297,6 +297,37 @@ public protocol _Indexable : _IndexableBase {
   ///   `RandomAccessCollection`; otherwise, O(*n*), where *n* is the
   ///   resulting distance.
   func distance(from start: Index, to end: Index) -> IndexDistance
+
+  /// A Boolean value indicating whether the collection is empty.
+  ///
+  /// When you need to check whether your collection is empty, use the
+  /// `isEmpty` property instead of checking that the `count` property is
+  /// equal to zero. For collections that don't conform to
+  /// `RandomAccessCollection`, accessing the `count` property iterates
+  /// through the elements of the collection.
+  ///
+  ///     let horseName = "Silver"
+  ///     if horseName.isEmpty {
+  ///         print("I've been through the desert on a horse with no name.")
+  ///     } else {
+  ///         print("Hi ho, \(horseName)!")
+  ///     }
+  ///     // Prints "Hi ho, Silver!")
+  ///
+  /// - Complexity: O(1)
+  var isEmpty: Bool { get }
+
+  /// The number of elements in the collection.
+  ///
+  /// To check whether a collection is empty, use its `isEmpty` property
+  /// instead of comparing `count` to zero. Unless the collection guarantees
+  /// random-access performance, calculating `count` can be an O(*n*)
+  /// operation.
+  ///
+  /// - Complexity: O(1) if the collection conforms to
+  ///   `RandomAccessCollection`; otherwise, O(*n*), where *n* is the length
+  ///   of the collection.
+  var count: IndexDistance { get }  
 }
 
 /// A type that iterates over a collection using its indices.
@@ -853,37 +884,6 @@ public protocol Collection : _Indexable, Sequence
   /// - Complexity: O(1)
   func prefix(through position: Index) -> SubSequence
 
-  /// A Boolean value indicating whether the collection is empty.
-  ///
-  /// When you need to check whether your collection is empty, use the
-  /// `isEmpty` property instead of checking that the `count` property is
-  /// equal to zero. For collections that don't conform to
-  /// `RandomAccessCollection`, accessing the `count` property iterates
-  /// through the elements of the collection.
-  ///
-  ///     let horseName = "Silver"
-  ///     if horseName.isEmpty {
-  ///         print("I've been through the desert on a horse with no name.")
-  ///     } else {
-  ///         print("Hi ho, \(horseName)!")
-  ///     }
-  ///     // Prints "Hi ho, Silver!")
-  ///
-  /// - Complexity: O(1)
-  var isEmpty: Bool { get }
-
-  /// The number of elements in the collection.
-  ///
-  /// To check whether a collection is empty, use its `isEmpty` property
-  /// instead of comparing `count` to zero. Unless the collection guarantees
-  /// random-access performance, calculating `count` can be an O(*n*)
-  /// operation.
-  ///
-  /// - Complexity: O(1) if the collection conforms to
-  ///   `RandomAccessCollection`; otherwise, O(*n*), where *n* is the length
-  ///   of the collection.
-  var count: IndexDistance { get }
-
   // The following requirement enables dispatching for index(of:) when
   // the element type is Equatable.
   /// Returns `Optional(Optional(index))` if an element was found

stdlib/public/core/DoubleWidth.swift.gyb

@@ -12,8 +12,7 @@
 
 /// A fixed-width integer that is twice the size of its base type.
 public struct DoubleWidth<Base : FixedWidthInteger> :
-  FixedWidthInteger, _ExpressibleByBuiltinIntegerLiteral
-  where Base.Words : Collection, Base.Magnitude.Words : Collection {
+  FixedWidthInteger, _ExpressibleByBuiltinIntegerLiteral {
 
   public typealias High = Base
   public typealias Low = Base.Magnitude
@@ -235,7 +234,8 @@ public struct DoubleWidth<Base : FixedWidthInteger> :
       if Base.bitWidth < UInt.bitWidth {
         _precondition(i == Index(.low(_low.startIndex)), "Invalid index")
         _sanityCheck(2 * Base.bitWidth <= UInt.bitWidth)
-        return _low.first! | (_high.first! &<< Base.bitWidth._lowWord) 
+        return _low[_low.startIndex] | 
+          (_high[_high.startIndex] &<< Base.bitWidth._lowWord) 
       }
       switch i._value {
       case let .low(li): return _low[li]

stdlib/public/core/Integers.swift.gyb

@@ -1469,11 +1469,11 @@ public protocol BinaryInteger :
 
   // FIXME: Should be `Words : Collection where Words.Element == UInt`
   // See <rdar://problem/31798916> for why it isn't.
-  /// A type that represents the words of a binary integer.
+  /// A type that represents the words of a binary integer. 
   ///
   /// The `Words` type must conform to the `Collection` protocol with an
   /// `Element` type of `UInt`.
-  associatedtype Words : Sequence where Words.Element == UInt
+  associatedtype Words : Sequence, _Indexable where Words.Element == UInt
 
   /// A collection containing the words of this value's binary
   /// representation, in order from the least significant to most significant.

test/Compatibility/string_collection.swift

@@ -6,7 +6,7 @@ extension String : Collection { // expected-warning{{conformance of 'String' to
     set { }
   }
 
-  var isEmpty: Bool { return false } // expected-note{{var 'isEmpty' will not be used to satisfy the conformance to 'Collection'}}
+  var first: Character? { return nil } // expected-note{{var 'first' will not be used to satisfy the conformance to 'Collection'}}
 
 }
 

validation-test/stdlib/CollectionDiagnostics.swift

@@ -57,6 +57,8 @@ struct GoodIndexable : Indexable {
   func index(after i: Int) -> Int { return i + 1 }
   var startIndex: Int { return 0 }
   var endIndex: Int { return 0 }
+  var isEmpty: Bool { return true }
+  var count: Int { return 0 }
 
   subscript(pos: Int) -> Int { return 0 }
   subscript(bounds: Range<Int>) -> [Int] { return [] }
@@ -69,6 +71,8 @@ struct BadIndexable1 : Indexable {
   func index(after i: Int) -> Int { return i + 1 }
   var startIndex: Int { return 0 }
   var endIndex: Int { return 0 }
+  var isEmpty: Bool { return true }
+  var count: Int { return 0 }
 
   subscript(pos: Int) -> Int { return 0 }
 
@@ -80,6 +84,8 @@ struct BadIndexable1 : Indexable {
 struct BadIndexable2 : Indexable {
   var startIndex: Int { return 0 }
   var endIndex: Int { return 0 }
+  var isEmpty: Bool { return true }
+  var count: Int { return 0 }
 
   subscript(pos: Int) -> Int { return 0 }
   subscript(bounds: Range<Int>) -> [Int] { return [] }
@@ -90,6 +96,8 @@ struct BadIndexable2 : Indexable {
 struct GoodBidirectionalIndexable1 : BidirectionalIndexable {
   var startIndex: Int { return 0 }
   var endIndex: Int { return 0 }
+  var isEmpty: Bool { return true }
+  var count: Int { return 0 }
   func index(after i: Int) -> Int { return i + 1 }
   func index(before i: Int) -> Int { return i - 1 }
 
@@ -103,6 +111,8 @@ struct GoodBidirectionalIndexable1 : BidirectionalIndexable {
 struct BadBidirectionalIndexable : BidirectionalIndexable {
   var startIndex: Int { return 0 }
   var endIndex: Int { return 0 }
+  var isEmpty: Bool { return true }
+  var count: Int { return 0 }
 
   subscript(pos: Int) -> Int { return 0 }
   subscript(bounds: Range<Int>) -> [Int] { return [] }
@@ -121,6 +131,8 @@ struct BadBidirectionalIndexable : BidirectionalIndexable {
 struct RangeReplaceableCollection_SubSequence_IsDefaulted : RangeReplaceableCollection {
   var startIndex: Int { fatalError() }
   var endIndex: Int { fatalError() }
+  var isEmpty: Bool { return true }
+  var count: Int { return 0 }
 
   subscript(pos: Int) -> Int { return 0 }