[stdlib] Use CountableRange for Indices more

This will be much more efficient than the default, when it applies,
because it doesn't need to carry a reference to underlying collection
storage.

Author: Dave Abrahams

stdlib/public/core/Character.swift

@@ -137,6 +137,10 @@ public struct Character :
   }
 
   internal struct _SmallUTF8 : RandomAccessCollection {
+    var indices: CountableRange<Int> {
+      return startIndex..<endIndex
+    }
+
     init(_ u8: UInt64) {
       let utf8Count = Character._smallSize(u8)
       _sanityCheck(utf8Count <= 8, "Character with more than 8 UTF-8 code units")
@@ -199,6 +203,10 @@ public struct Character :
   }
 
   struct _SmallUTF16 : RandomAccessCollection {
+    var indices: CountableRange<Int> {
+      return startIndex..<endIndex
+    }
+    
     init(_ u8: UInt64) {
       let count = UTF16.transcodedLength(
         of: _SmallUTF8(u8).makeIterator(),

stdlib/public/core/CocoaArray.swift

@@ -26,6 +26,10 @@ import SwiftShims
 /// `_NSArrayCore` conform directly?  It's a class, and I
 /// don't want to pay for the dynamic dispatch overhead.
 internal struct _CocoaArrayWrapper : RandomAccessCollection {
+  public var indices: CountableRange<Int> {
+    return startIndex..<endIndex
+  }
+  
   var startIndex: Int {
     return 0
   }

stdlib/public/core/CollectionOfOne.swift

@@ -37,6 +37,10 @@ public struct IteratorOverOne<Element> : IteratorProtocol, Sequence {
 /// A collection containing a single element of type `Element`.
 public struct CollectionOfOne<Element> : RandomAccessCollection {
 
+  public var indices: CountableRange<Int> {
+    return startIndex..<endIndex
+  }
+
   /// Construct an instance containing just `element`.
   public init(_ element: Element) {
     self._element = element

stdlib/public/core/Mirror.swift

@@ -526,6 +526,11 @@ internal extension Mirror {
   /// mirrors to use the new style, which only present forward
   /// traversal in general.
   internal struct LegacyChildren : RandomAccessCollection {
+
+    public var indices: CountableRange<Int> {
+      return startIndex..<endIndex
+    }
+    
     init(_ oldMirror: _Mirror) {
       self._oldMirror = oldMirror
     }
@@ -754,6 +759,11 @@ public struct DictionaryLiteral<Key, Value> : DictionaryLiteralConvertible {
 /// `Collection` conformance that allows `DictionaryLiteral` to
 /// interoperate with the rest of the standard library.
 extension DictionaryLiteral : RandomAccessCollection {
+
+  public var indices: CountableRange<Int> {
+    return startIndex..<endIndex
+  }
+  
   /// The position of the first element in a non-empty `DictionaryLiteral`.
   ///
   /// Identical to `endIndex` in an empty `DictionaryLiteral`.

stdlib/public/core/Repeat.swift

@@ -12,6 +12,11 @@
 
 /// A collection whose elements are all identical `Element`s.
 public struct Repeated<Element> : RandomAccessCollection {
+
+  public var indices: CountableRange<Int> {
+    return startIndex..<endIndex
+  }
+
   /// A type that represents a valid position in the collection.
   /// 
   /// Valid indices consist of the position of every element and a

stdlib/public/core/StringCore.swift

@@ -572,6 +572,11 @@ public struct _StringCore {
 }
 
 extension _StringCore : RandomAccessCollection {
+  
+  public var indices: CountableRange<Int> {
+    return startIndex..<endIndex
+  }
+
   public // @testable
   var startIndex: Int {
     return 0

stdlib/public/core/UnicodeScalar.swift

@@ -239,6 +239,11 @@ extension UnicodeScalar {
 }
 
 extension UnicodeScalar.UTF16View : RandomAccessCollection {
+
+  public var indices: CountableRange<Int> {
+    return startIndex..<endIndex
+  }
+
   /// The position of the first code unit.
   var startIndex: Int {
     return 0