[stdlib] Suppress noisy warnings

docs/Literals.rst

@@ -138,6 +138,6 @@ literal type is always Dictionary.
 
 String interpolations are a bit different: they try to individually convert
 each element of the interpolation to the type that adopts
-ExpressibleByStringInterpolation, then calls the variadic
+_ExpressibleByStringInterpolation, then calls the variadic
 ``convertFromStringInterpolation`` to put them all together. The default type
 for an interpolated literal without context is also ``StringLiteralType``.

include/swift/AST/DiagnosticsSema.def

@@ -2107,10 +2107,10 @@ ERROR(optional_used_as_boolean,none,
      "test for '!= nil' instead", (Type))
 
 ERROR(interpolation_missing_proto,none,
-      "string interpolation requires the protocol 'ExpressibleByStringInterpolation' to be defined",
+      "string interpolation requires the protocol '_ExpressibleByStringInterpolation' to be defined",
       ())
 ERROR(interpolation_broken_proto,none,
-      "protocol 'ExpressibleByStringInterpolation' is broken",
+      "protocol '_ExpressibleByStringInterpolation' is broken",
       ())
 
 ERROR(object_literal_broken_proto,none,

include/swift/AST/KnownProtocols.def

@@ -71,7 +71,7 @@ EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByDictionaryLiteral)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByExtendedGraphemeClusterLiteral)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByFloatLiteral)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByIntegerLiteral)
-EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByStringInterpolation)
+EXPRESSIBLE_BY_LITERAL_PROTOCOL_(ExpressibleByStringInterpolation)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByStringLiteral)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByNilLiteral)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByUnicodeScalarLiteral)

stdlib/private/StdlibCollectionUnittest/CheckCollectionInstance.swift.gyb

@@ -40,8 +40,8 @@ public struct CollectionMisuseResiliencyChecks {
 }
 
 % for inc, protocol, direction, end in (
-%  ('inc', 'Indexable', 'after', 'end'),
-%  ('dec', 'BidirectionalIndexable', 'before', 'start')):
+%  ('inc', '_Indexable', 'after', 'end'),
+%  ('dec', '_BidirectionalIndexable', 'before', 'start')):
 
 /// Test that the elements of `instances` satisfy
 /// ${'some of ' if inc == 'dec' else ''}the semantic
@@ -91,7 +91,7 @@ internal func _checkIncrementalAdvance<Instances, BaseCollection>(
   ${TRACE}
 ) where
   Instances : Collection,
-  BaseCollection : Indexable,
+  BaseCollection : _Indexable,
   Instances.Iterator.Element == BaseCollection.Index,
   // FIXME(compiler limitation): these constraints should be applied to
   // associated types of Collection.
@@ -128,7 +128,7 @@ public func checkForwardIndex<Instances, BaseCollection>(
   endIndex: Instances.Iterator.Element, ${TRACE}
 ) where
   Instances : Collection,
-  BaseCollection : Indexable,
+  BaseCollection : _Indexable,
   Instances.Iterator.Element == BaseCollection.Index,
   // FIXME(compiler limitation): these constraints should be applied to
   // associated types of Collection.
@@ -158,7 +158,7 @@ public func checkBidirectionalIndex<Instances, BaseCollection>(
   ${TRACE}
 ) where
   Instances: Collection,
-  BaseCollection : BidirectionalIndexable,
+  BaseCollection : _BidirectionalIndexable,
   Instances.Iterator.Element == BaseCollection.Index,
   // FIXME(compiler limitation): these constraints should be applied to
   // associated types of Collection.
@@ -197,7 +197,7 @@ public func checkRandomAccessIndex<Instances, Distances, BaseCollection>(
 ) where
   Instances : Collection,
   Distances : Collection,
-  BaseCollection : RandomAccessIndexable,
+  BaseCollection : _RandomAccessIndexable,
   Instances.Iterator.Element == BaseCollection.Index,
   Distances.Iterator.Element == BaseCollection.IndexDistance,
   // FIXME(compiler limitation): these constraints should be applied to
@@ -230,7 +230,7 @@ public func checkAdvancesAndDistances<Instances, Distances, BaseCollection>(
 ) where
   Instances : Collection,
   Distances : Collection,
-  BaseCollection : Indexable,
+  BaseCollection : _Indexable,
   Instances.Iterator.Element == BaseCollection.Index,
   Distances.Iterator.Element == BaseCollection.IndexDistance,
   // FIXME(compiler limitation): these constraints should be applied to

stdlib/public/SDK/Foundation/Data.swift

@@ -735,10 +735,10 @@ extension Data : CustomStringConvertible, CustomDebugStringConvertible, CustomRe
 
 extension Data {
     @available(*, unavailable, renamed: "copyBytes(to:count:)")
-    public func getBytes(_ buffer: UnsafeMutablePointer<Swift.Void>, length: Int) { }
+  public func getBytes<UnsafeMutablePointerVoid: _Pointer>(_ buffer: UnsafeMutablePointerVoid, length: Int) { }
 
     @available(*, unavailable, renamed: "copyBytes(to:from:)")
-    public func getBytes(_ buffer: UnsafeMutablePointer<Swift.Void>, range: NSRange) { }
+    public func getBytes<UnsafeMutablePointerVoid: _Pointer>(_ buffer: UnsafeMutablePointerVoid, range: NSRange) { }
 }
 
 /// Provides bridging functionality for struct Data to class NSData and vice-versa.

stdlib/public/core/BidirectionalCollection.swift

@@ -17,7 +17,8 @@
 /// `BidirectionalCollection` protocol instead, because it has a more complete
 /// interface.
 @available(*, deprecated, message: "it will be removed in Swift 4.0.  Please use 'BidirectionalCollection' instead")
-public protocol BidirectionalIndexable : Indexable {
+public typealias BidirectionalIndexable = _BidirectionalIndexable
+public protocol _BidirectionalIndexable : _Indexable {
   // FIXME(ABI)(compiler limitation): there is no reason for this protocol
   // to exist apart from missing compiler features that we emulate with it.
   // rdar://problem/20531108
@@ -65,7 +66,7 @@ public protocol BidirectionalIndexable : Indexable {
 /// - If `i > c.startIndex && i <= c.endIndex`
 ///   `c.index(after: c.index(before: i)) == i`.
 public protocol BidirectionalCollection
-  : BidirectionalIndexable, Collection {
+  : _BidirectionalIndexable, Collection {
 
 // TODO: swift-3-indexing-model - replaces functionality in BidirectionalIndex
   /// Returns the position immediately before the given index.
@@ -83,18 +84,37 @@ public protocol BidirectionalCollection
 
   /// A sequence that can represent a contiguous subrange of the collection's
   /// elements.
-  associatedtype SubSequence : BidirectionalIndexable, Collection
+  associatedtype SubSequence : _BidirectionalIndexable, Collection
     = BidirectionalSlice<Self>
   // FIXME(compiler limitation):
   // associatedtype SubSequence : BidirectionalCollection
 
   /// A type that can represent the indices that are valid for subscripting the
   /// collection, in ascending order.
-  associatedtype Indices : BidirectionalIndexable, Collection
+  associatedtype Indices : _BidirectionalIndexable, Collection
     = DefaultBidirectionalIndices<Self>
   // FIXME(compiler limitation):
   // associatedtype Indices : BidirectionalCollection
 
+  /// The indices that are valid for subscripting the collection, in ascending
+  /// order.
+  ///
+  /// A collection's `indices` property can hold a strong reference to the
+  /// collection itself, causing the collection to be non-uniquely referenced.
+  /// If you mutate the collection while iterating over its indices, a strong
+  /// reference can cause an unexpected copy of the collection. To avoid the
+  /// unexpected copy, use the `index(after:)` method starting with
+  /// `startIndex` to produce indices instead.
+  ///
+  ///     var c = MyFancyCollection([10, 20, 30, 40, 50])
+  ///     var i = c.startIndex
+  ///     while i != c.endIndex {
+  ///         c[i] /= 5
+  ///         i = c.index(after: i)
+  ///     }
+  ///     // c == MyFancyCollection([2, 4, 6, 8, 10])
+  var indices: Indices { get }
+
   // TODO: swift-3-indexing-model: tests.
   /// The last element of the collection.
   ///
@@ -111,7 +131,7 @@ public protocol BidirectionalCollection
 }
 
 /// Default implementation for bidirectional collections.
-extension BidirectionalIndexable {
+extension _BidirectionalIndexable {
 
   @inline(__always)
   public func formIndex(before i: inout Index) {

stdlib/public/core/Builtin.swift

@@ -193,12 +193,12 @@ internal func _isClassOrObjCExistential<T>(_ x: T.Type) -> Bool {
 /// not much you can do with this other than use it to identify the
 /// object.
 @available(*, unavailable, message: "Removed in Swift 3. Use Unmanaged.passUnretained(x).toOpaque() instead.")
-public func unsafeAddress(of object: AnyObject) -> UnsafePointer<Void> {
+public func unsafeAddress(of object: AnyObject) -> UnsafeRawPointer {
   Builtin.unreachable()
 }
 
 @available(*, unavailable, message: "Removed in Swift 3. Use Unmanaged.passUnretained(x).toOpaque() instead.")
-public func unsafeAddressOf(_ object: AnyObject) -> UnsafePointer<Void> {
+public func unsafeAddressOf(_ object: AnyObject) -> UnsafeRawPointer {
   Builtin.unreachable()
 }
 

stdlib/public/core/Collection.swift

@@ -16,7 +16,8 @@
 /// In most cases, it's best to ignore this protocol and use the `Collection`
 /// protocol instead, because it has a more complete interface.
 @available(*, deprecated, message: "it will be removed in Swift 4.0.  Please use 'Collection' instead")
-public protocol IndexableBase {
+public typealias IndexableBase = _IndexableBase
+public protocol _IndexableBase {
   // FIXME(ABI)(compiler limitation): there is no reason for this protocol
   // to exist apart from missing compiler features that we emulate with it.
   // rdar://problem/20531108
@@ -159,7 +160,8 @@ public protocol IndexableBase {
 /// In most cases, it's best to ignore this protocol and use the `Collection`
 /// protocol instead, because it has a more complete interface.
 @available(*, deprecated, message: "it will be removed in Swift 4.0.  Please use 'Collection' instead")
-public protocol Indexable : IndexableBase {
+public typealias Indexable = _Indexable
+public protocol _Indexable : _IndexableBase {
   /// A type used to represent the number of steps between two indices, where
   /// one value is reachable from the other.
   ///
@@ -354,7 +356,7 @@ public protocol Indexable : IndexableBase {
 ///     // Prints "15.0"
 ///     // Prints "20.0"
 public struct IndexingIterator<
-  Elements : IndexableBase
+  Elements : _IndexableBase
   // FIXME(compiler limitation):
   // Elements : Collection
 > : IteratorProtocol, Sequence {
@@ -530,7 +532,7 @@ public struct IndexingIterator<
 /// forward or bidirectional collection must traverse the entire collection to
 /// count the number of contained elements, accessing its `count` property is
 /// an O(*n*) operation.
-public protocol Collection : Indexable, Sequence {
+public protocol Collection : _Indexable, Sequence {
   /// A type that can represent the number of steps between a pair of
   /// indices.
   associatedtype IndexDistance : SignedInteger = Int
@@ -555,7 +557,7 @@ public protocol Collection : Indexable, Sequence {
   /// This associated type appears as a requirement in the `Sequence`
   /// protocol, but it is restated here with stricter constraints. In a
   /// collection, the subsequence should also conform to `Collection`.
-  associatedtype SubSequence : IndexableBase, Sequence = Slice<Self>
+  associatedtype SubSequence : _IndexableBase, Sequence = Slice<Self>
   // FIXME(compiler limitation):
   // associatedtype SubSequence : Collection
   //   where
@@ -614,7 +616,7 @@ public protocol Collection : Indexable, Sequence {
 
   /// A type that can represent the indices that are valid for subscripting the
   /// collection, in ascending order.
-  associatedtype Indices : IndexableBase, Sequence = DefaultIndices<Self>
+  associatedtype Indices : _Indexable, Sequence = DefaultIndices<Self>
 
   // FIXME(compiler limitation):
   // associatedtype Indices : Collection
@@ -859,7 +861,7 @@ public protocol Collection : Indexable, Sequence {
 }
 
 /// Default implementation for forward collections.
-extension Indexable {
+extension _Indexable {
   /// Replaces the given index with its successor.
   ///
   /// - Parameter i: A valid index of the collection. `i` must be less than
@@ -1702,7 +1704,7 @@ extension Collection {
 public enum Bit {}
 
 @available(*, unavailable, renamed: "IndexingIterator")
-public struct IndexingGenerator<Elements : IndexableBase> {}
+public struct IndexingGenerator<Elements : _IndexableBase> {}
 
 @available(*, unavailable, renamed: "Collection")
 public typealias CollectionType = Collection

stdlib/public/core/CollectionAlgorithms.swift.gyb

@@ -469,7 +469,7 @@ ${orderingExplanation}
   }
 }
 
-% for Self in 'Indexable', 'MutableIndexable':
+% for Self in '_Indexable', '_MutableIndexable':
 %{
 
 subscriptCommentPre = """\

stdlib/public/core/CompilerProtocols.swift

@@ -614,7 +614,8 @@ public protocol ExpressibleByDictionaryLiteral {
 ///           String(stringInterpolationSegment: price * number),
 ///           String(stringInterpolationSegment: "."))
 @available(*, deprecated, message: "it will be replaced or redesigned in Swift 4.0.  Instead of conforming to 'ExpressibleByStringInterpolation', consider adding an 'init(_:String)'")
-public protocol ExpressibleByStringInterpolation {
+public typealias ExpressibleByStringInterpolation = _ExpressibleByStringInterpolation
+public protocol _ExpressibleByStringInterpolation {
   /// Creates an instance by concatenating the given values.
   ///
   /// Do not call this initializer directly. It is used by the compiler when

stdlib/public/core/ExistentialCollection.swift.gyb

@@ -799,6 +799,9 @@ protocol _AnyCollectionProtocol : Collection {
 public struct ${Self}<Element>
   : _AnyCollectionProtocol, ${SelfProtocol} {
 
+//  public typealias Indices
+//    = Default${Traversal.replace('Forward', '')}Indices<${Self}>
+
   internal init(_box: _${Self}Box<Element>) {
     self._box = _box
   }

stdlib/public/core/HashedCollections.swift.gyb

@@ -2211,7 +2211,7 @@ public func _dictionaryUpCast<DerivedKey, DerivedValue, BaseKey, BaseValue>(
   var result = Dictionary<BaseKey, BaseValue>(minimumCapacity: source.count)
 
   for (k, v) in source {
-    result[k as! BaseKey] = v as! BaseValue
+    result[k as! BaseKey] = (v as! BaseValue)
   }
   return result
 }

stdlib/public/core/Indices.swift.gyb

@@ -30,7 +30,7 @@ from gyb_stdlib_support import (
 
 /// A collection of indices for an arbitrary ${collection}.
 public struct ${Self}<
-  Elements : ${collectionForTraversal(Traversal).replace('Collection', 'Indexable')}
+  Elements : _${collectionForTraversal(Traversal).replace('Collection', 'Indexable')}
   // FIXME(ABI)(compiler limitation):
   // Elements : Collection
   // rdar://problem/20531108

stdlib/public/core/MutableCollection.swift

@@ -16,7 +16,8 @@
 /// `MutableCollection` protocol instead, because it has a more complete
 /// interface.
 @available(*, deprecated, message: "it will be removed in Swift 4.0.  Please use 'MutableCollection' instead")
-public protocol MutableIndexable : Indexable {
+public typealias MutableIndexable = _MutableIndexable
+public protocol _MutableIndexable : _Indexable {
   // FIXME(ABI)(compiler limitation): there is no reason for this protocol
   // to exist apart from missing compiler features that we emulate with it.
   // rdar://problem/20531108
@@ -216,7 +217,7 @@ public protocol MutableIndexable : Indexable {
 ///     // Must be equivalent to:
 ///     a[i] = x
 ///     let y = x
-public protocol MutableCollection : MutableIndexable, Collection {
+public protocol MutableCollection : _MutableIndexable, Collection {
   // FIXME: should be constrained to MutableCollection
   // (<rdar://problem/20715009> Implement recursive protocol
   // constraints)

stdlib/public/core/RandomAccessCollection.swift

@@ -16,7 +16,8 @@
 /// `RandomAccessCollection` protocol instead, because it has a more complete
 /// interface.
 @available(*, deprecated, message: "it will be removed in Swift 4.0.  Please use 'RandomAccessCollection' instead")
-public protocol RandomAccessIndexable : BidirectionalIndexable {
+public typealias RandomAccessIndexable = _RandomAccessIndexable
+public protocol _RandomAccessIndexable : _BidirectionalIndexable {
   // FIXME(ABI)(compiler limitation): there is no reason for this protocol
   // to exist apart from missing compiler features that we emulate with it.
   // rdar://problem/20531108
@@ -46,21 +47,40 @@ public protocol RandomAccessIndexable : BidirectionalIndexable {
 /// `Strideable` protocol or you must implement the `index(_:offsetBy:)` and
 /// `distance(from:to:)` methods with O(1) efficiency.
 public protocol RandomAccessCollection :
-  RandomAccessIndexable, BidirectionalCollection
+  _RandomAccessIndexable, BidirectionalCollection
 {
   /// A collection that represents a contiguous subrange of the collection's
   /// elements.
-  associatedtype SubSequence : RandomAccessIndexable, BidirectionalCollection
+  associatedtype SubSequence : _RandomAccessIndexable, BidirectionalCollection
     = RandomAccessSlice<Self>
   // FIXME(compiler limitation):
   // associatedtype SubSequence : RandomAccessCollection
 
   /// A type that can represent the indices that are valid for subscripting the
   /// collection, in ascending order.
-  associatedtype Indices : RandomAccessIndexable, BidirectionalCollection
+  associatedtype Indices : _RandomAccessIndexable, BidirectionalCollection
     = DefaultRandomAccessIndices<Self>
   // FIXME(compiler limitation):
   // associatedtype Indices : RandomAccessCollection
+
+  /// The indices that are valid for subscripting the collection, in ascending
+  /// order.
+  ///
+  /// A collection's `indices` property can hold a strong reference to the
+  /// collection itself, causing the collection to be non-uniquely referenced.
+  /// If you mutate the collection while iterating over its indices, a strong
+  /// reference can cause an unexpected copy of the collection. To avoid the
+  /// unexpected copy, use the `index(after:)` method starting with
+  /// `startIndex` to produce indices instead.
+  ///
+  ///     var c = MyFancyCollection([10, 20, 30, 40, 50])
+  ///     var i = c.startIndex
+  ///     while i != c.endIndex {
+  ///         c[i] /= 5
+  ///         i = c.index(after: i)
+  ///     }
+  ///     // c == MyFancyCollection([2, 4, 6, 8, 10])
+  var indices: Indices { get }
 }
 
 /// Supply the default "slicing" `subscript` for `RandomAccessCollection`
@@ -103,7 +123,7 @@ extension RandomAccessCollection where SubSequence == RandomAccessSlice<Self> {
 // wrong complexity.
 
 /// Default implementation for random access collections.
-extension RandomAccessIndexable {
+extension _RandomAccessIndexable {
   /// Returns an index that is the specified distance from the given index,
   /// unless that distance is beyond a given limiting index.
   ///