Merge pull request #18403 from apple/tensorflow-merge

Merges upstream changes from swift-DEVELOPMENT-SNAPSHOT-2018-07-23-a into tensorflow

Author: bgogul

CHANGELOG.md

@@ -24,9 +24,14 @@ CHANGELOG
 Swift 5.0
 ---------
 
-- [SR-419][]
+* Notable bug fix: unowned and unowned(unsafe) variables now support optional
+  types.
 
-  In Swift 5 mode, when setting a property from within its own `didSet` or `willSet` observer, the observer will now only avoid being recursively called if the property is set on `self` (either implicitly or explicitly).
+* [SR-419][]
+
+  In Swift 5 mode, when setting a property from within its own `didSet` or
+  `willSet` observer, the observer will now only avoid being recursively called
+  if the property is set on `self` (either implicitly or explicitly).
 
   For example:
   ```swift

benchmark/CMakeLists.txt

@@ -66,6 +66,7 @@ set(SWIFT_BENCH_MODULES
     single-source/DictTest4Legacy
     single-source/DictionaryBridge
     single-source/DictionaryBridgeToObjC
+    single-source/DictionaryCompactMapValues
     single-source/DictionaryCopy
     single-source/DictionaryGroup
     single-source/DictionaryKeysContains

benchmark/single-source/ArrayAppend.swift

@@ -202,7 +202,7 @@ public func run_ArrayAppendRepeatCol(_ N: Int) {
 @inline(never)
 public func appendFromGeneric<
   S: Sequence
->(array: inout [S.Iterator.Element], sequence: S) {
+>(array: inout [S.Element], sequence: S) {
   array.append(contentsOf: sequence)
 }
 
@@ -224,7 +224,7 @@ public func run_ArrayAppendFromGeneric(_ N: Int) {
 @inline(never)
 public func appendToGeneric<
   R: RangeReplaceableCollection
->(collection: inout R, array: [R.Iterator.Element]) {
+>(collection: inout R, array: [R.Element]) {
   collection.append(contentsOf: array)
 }
 
@@ -248,7 +248,7 @@ public func run_ArrayAppendToGeneric(_ N: Int) {
 public func appendToFromGeneric<
   R: RangeReplaceableCollection, S: Sequence
 >(collection: inout R, sequence: S) 
-where R.Iterator.Element == S.Iterator.Element {
+where R.Element == S.Element {
   collection.append(contentsOf: sequence)
 }
 

benchmark/single-source/COWTree.swift

@@ -69,7 +69,7 @@ public struct Tree<T: Comparable> {
   public init() { }
 
   // constructor from a sequence
-  public init<S: Sequence>(_ seq: S) where S.Iterator.Element == T {
+  public init<S: Sequence>(_ seq: S) where S.Element == T {
     var g = seq.makeIterator()
     while let x = g.next() {
       self.insert(x)

benchmark/single-source/CaptureProp.swift

@@ -24,7 +24,7 @@ func sum(_ x:Int, y:Int) -> Int {
 @inline(never)
 func benchCaptureProp<S : Sequence
 >(
-  _ s: S, _ f: (S.Iterator.Element, S.Iterator.Element) -> S.Iterator.Element) -> S.Iterator.Element {
+  _ s: S, _ f: (S.Element, S.Element) -> S.Element) -> S.Element {
 
   var it = s.makeIterator()
   let initial = it.next()!

benchmark/single-source/Combos.swift

@@ -33,7 +33,7 @@ public func run_Combos(_ N: Int) {
 func combinations
 <First: Sequence, Second: Collection>
 (_ first: First, _ second: Second)
--> AnyIterator<(First.Iterator.Element, Second.Iterator.Element)> {
+-> AnyIterator<(First.Element, Second.Element)> {
   var first_gen = first.makeIterator()
   var second_gen = second.makeIterator()
   var current_first = first_gen.next()

benchmark/single-source/DictOfArraysToArrayOfDicts.swift

@@ -61,21 +61,14 @@ public func run_DictOfArraysToArrayOfDicts(_ N: Int) {
 //  "time"  : "0123",
 //  "content": "zxcvb"]]
 
-public func zip3 <A: Sequence,
-B: Sequence,
-C: Sequence> (_ a: A, _ b: B, _ c: C)
--> ZipSequence3<A, B, C> {
+public func zip3 <
+  A: Sequence,B: Sequence,C: Sequence
+> (_ a: A, _ b: B, _ c: C) -> ZipSequence3<A, B, C> {
   return ZipSequence3(a, b, c)
 }
 
 // Sequence of tuples created from values from three other sequences
-public struct ZipSequence3<A: Sequence,
-B: Sequence,
-C: Sequence>: Sequence {
-  public typealias Iterator = ZipGenerator3
-  <A.Iterator, B.Iterator, C.Iterator>
-  public typealias SubSequence = AnySequence<Iterator.Element>
-
+public struct ZipSequence3<A: Sequence,B: Sequence,C: Sequence> {
   private var a: A
   private var b: B
   private var c: C
@@ -84,43 +77,53 @@ C: Sequence>: Sequence {
     self.a = a
     self.b = b
     self.c = c
-  }
-
-  public func makeIterator() -> Iterator {
-    return ZipGenerator3(a.makeIterator(), b.makeIterator(), c.makeIterator())
-  }
+  }  
 }
 
-// Iterator that creates tuples of values from three other generators
-public struct ZipGenerator3<A: IteratorProtocol,
-B: IteratorProtocol,
-C: IteratorProtocol>: IteratorProtocol {
-  private var a: A
-  private var b: B
-  private var c: C
+extension ZipSequence3 {
+  public struct Iterator {
+    private var a: A.Iterator
+    private var b: B.Iterator
+    private var c: C.Iterator
 
-  public init(_ a: A, _ b: B, _ c: C) {
-    self.a = a
-    self.b = b
-    self.c = c
+    public init(_ a: A, _ b: B, _ c: C) {
+      self.a = a.makeIterator()
+      self.b = b.makeIterator()
+      self.c = c.makeIterator()
+    }
   }
+}
 
-  mutating public func next() -> (A.Element, B.Element, C.Element)? {
+extension ZipSequence3.Iterator: IteratorProtocol {
+  public typealias Element = (A.Element,B.Element,C.Element)
+  
+  public mutating func next() -> Element? {
     switch (a.next(), b.next(), c.next()) {
-    case let (.some(aValue), .some(bValue), .some(cValue)):
+    case let (aValue?, bValue?, cValue?):
       return (aValue, bValue, cValue)
     default:
       return nil
     }
   }
 }
 
-func zipWith
-<S1: Sequence, S2: Sequence, S3: Sequence, T>
-(_ s1: S1, _ s2: S2, _ s3: S3, _ combine: (S1.Iterator.Element,
-    S2.Iterator.Element,
-    S3.Iterator.Element) -> T) -> [T] {
-  return zip3(s1,s2,s3).map(combine)
+extension ZipSequence3: Sequence {
+  public typealias Element = (A.Element,B.Element,C.Element)
+  public typealias SubSequence = AnySequence<Element>
+
+  public func makeIterator() -> Iterator {
+    return Iterator(a, b, c)
+  }
+}
+
+// Iterator that creates tuples of values from three other generators
+func zipWith<
+  A: Sequence, B: Sequence, C: Sequence, T
+>(
+  _ a: A, _ b: B, _ c: C, 
+  _ combine: (A.Element,B.Element,C.Element) -> T
+) -> [T] {
+  return zip3(a,b,c).map(combine)
 }
 
 extension Dictionary {
@@ -132,7 +135,7 @@ extension Dictionary {
   }
 
   // Merge a sequence of `(Key,Value)` tuples into the dictionary
-  mutating func merge<S: Sequence> (_ seq: S) where S.Iterator.Element == Element {
+  mutating func merge<S: Sequence> (_ seq: S) where S.Element == Element {
     var gen = seq.makeIterator()
     while let (k, v) = gen.next() {
       self[k] = v

benchmark/single-source/DictionaryCompactMapValues.swift

@@ -0,0 +1,71 @@
+// Dictionary compact map values benchmark
+import TestsUtils
+
+public let DictionaryCompactMapValues = [
+  BenchmarkInfo(name: "DictionaryCompactMapValuesOfNilValue", runFunction: run_DictionaryCompactMapValuesOfNilValue, tags: [.validation, .api, .Dictionary]),
+  BenchmarkInfo(name: "DictionaryCompactMapValuesOfCastValue", runFunction: run_DictionaryCompactMapValuesOfCastValue, tags: [.validation, .api, .Dictionary]),
+]
+
+@inline(never)
+public func run_DictionaryCompactMapValuesOfNilValue(_ N: Int) {
+  let size = 100
+  var dict = [Int: Int?](minimumCapacity: size)
+
+  // Fill Dictionary
+  for i in 1...size {
+    if i % 2 == 0 {
+      dict[i] = nil
+    } else {
+      dict[i] = i
+    }
+  }
+  CheckResults(dict.count == size / 2)
+
+  var refDict = [Int: Int]()
+  for i in stride(from: 1, to: 100, by: 2) {
+    refDict[i] = i
+  }
+
+  var newDict = [Int: Int]()
+  for _ in 1...1000*N {
+    newDict = dict.compactMapValues({$0})
+    if newDict != refDict {
+      break
+    }
+  }
+
+  CheckResults(newDict == refDict)
+}
+
+@inline(never)
+public func run_DictionaryCompactMapValuesOfCastValue(_ N: Int) {
+  let size = 100
+  var dict = [Int: String](minimumCapacity: size)
+  
+  // Fill Dictionary
+  for i in 1...size {
+    if i % 2 == 0 {
+      dict[i] = "dummy"
+    } else {
+      dict[i] = "\(i)"
+    }
+  }
+  
+  CheckResults(dict.count == size)
+
+  var refDict = [Int: Int]()
+  for i in stride(from: 1, to: 100, by: 2) {
+    refDict[i] = i
+  }
+
+  var newDict = [Int: Int]()
+  for _ in 1...1000*N {
+    newDict = dict.compactMapValues(Int.init)
+    if newDict != refDict {
+      break
+    }
+  }
+  
+  CheckResults(newDict == refDict)
+}
+

benchmark/single-source/Histogram.swift

@@ -22,7 +22,7 @@ public let Histogram = BenchmarkInfo(
 typealias rrggbb_t = UInt32
 
 func output_sorted_sparse_rgb_histogram<S: Sequence>(_ samples: S, _ N: Int)
-  where S.Iterator.Element == rrggbb_t {
+  where S.Element == rrggbb_t {
   var histogram = Dictionary<rrggbb_t, Int>()
   for  _ in 1...50*N {
     for sample in samples {   // This part is really awful, I agree

benchmark/single-source/LuhnAlgoEager.swift

@@ -46,7 +46,7 @@ public func run_LuhnAlgoEager(_ N: Int) {
 // sequence and the transform function
 struct MapSomeSequenceView<Base: Sequence, T> {
     fileprivate let _base: Base
-    fileprivate let _transform: (Base.Iterator.Element) -> T?
+    fileprivate let _transform: (Base.Element) -> T?
 }
 
 // extend it to implement Sequence
@@ -77,7 +77,7 @@ extension LazyCollectionProtocol {
     // I might be missing a trick with this super-ugly return type, is there a
     // better way?
     func mapSome<U>(
-        _ transform: @escaping (Elements.Iterator.Element) -> U?
+        _ transform: @escaping (Elements.Element) -> U?
     ) -> LazySequence<MapSomeSequenceView<Elements, U>> {
         return MapSomeSequenceView(_base: elements, _transform: transform).lazy
     }
@@ -97,12 +97,12 @@ func isMultipleOf<T: FixedWidthInteger>(_ of: T)->(T)->Bool {
 extension LazySequenceProtocol {
   func mapEveryN(
     _ n: Int,
-    _ transform: @escaping (Iterator.Element) -> Iterator.Element
-  ) -> LazyMapSequence<EnumeratedSequence<Self>, Iterator.Element> {
+    _ transform: @escaping (Element) -> Element
+  ) -> LazyMapSequence<EnumeratedSequence<Self>, Element> {
     let isNth = isMultipleOf(n)
     func transform2(
-      _ pair: EnumeratedSequence<Self>.Iterator.Element
-    ) -> Iterator.Element {
+      _ pair: EnumeratedSequence<Self>.Element
+    ) -> Element {
       return isNth(pair.0 + 1) ? transform(pair.1) : pair.1
     }
     return self.enumerated().lazy.map(transform2)
@@ -143,7 +143,7 @@ let stringToInt = freeMemberFunc(String.toInt)
 let charToString = { (c: Character) -> String in String(c) }
 let charToInt = stringToInt • charToString
 
-func sum<S: Sequence>(_ nums: S)->S.Iterator.Element where S.Iterator.Element: FixedWidthInteger {
+func sum<S: Sequence>(_ nums: S)->S.Element where S.Element: FixedWidthInteger {
     return nums.reduce(0, +)
 }
 
@@ -154,29 +154,29 @@ func reverse<C: LazyCollectionProtocol>(
 }
 
 func map<S: LazySequenceProtocol, U>(
-  _ source: S, _ transform: @escaping (S.Elements.Iterator.Element)->U
+  _ source: S, _ transform: @escaping (S.Elements.Element)->U
 ) -> LazyMapSequence<S.Elements,U> {
   return source.map(transform)
 }
 
 func mapSome<C: LazyCollectionProtocol, U>(
     _ source: C,
-    _ transform: @escaping (C.Elements.Iterator.Element)->U?
+    _ transform: @escaping (C.Elements.Element)->U?
 ) -> LazySequence<MapSomeSequenceView<C.Elements, U>> {
     return source.mapSome(transform)
 }
 
 func mapEveryN<S: LazySequenceProtocol>(
     _ source: S, _ n: Int,
-    _ transform: @escaping (S.Iterator.Element)->S.Iterator.Element
-) -> LazyMapSequence<EnumeratedSequence<S>, S.Iterator.Element> {
+    _ transform: @escaping (S.Element)->S.Element
+) -> LazyMapSequence<EnumeratedSequence<S>, S.Element> {
     return source.mapEveryN(n, transform)
 }
 
 // Non-lazy version of mapSome:
 func mapSome<S: Sequence, C: RangeReplaceableCollection>(
     _ source: S,
-    _ transform: @escaping (S.Iterator.Element)->C.Iterator.Element?
+    _ transform: @escaping (S.Element)->C.Element?
 ) -> C {
     var result = C()
     for x in source {
@@ -191,7 +191,7 @@ func mapSome<S: Sequence, C: RangeReplaceableCollection>(
 // forcing the user having to specify:
 func mapSome<S: Sequence,U>(
     _ source: S,
-    _ transform: @escaping (S.Iterator.Element
+    _ transform: @escaping (S.Element
 )->U?)->[U] {
     // just calls the more generalized version
     return mapSome(source, transform)
@@ -200,11 +200,11 @@ func mapSome<S: Sequence,U>(
 // Non-lazy version of mapEveryN:
 func mapEveryN<S: Sequence>(
     _ source: S, _ n: Int,
-    _ transform: @escaping (S.Iterator.Element) -> S.Iterator.Element
-) -> [S.Iterator.Element] {
+    _ transform: @escaping (S.Element) -> S.Element
+) -> [S.Element] {
     let isNth = isMultipleOf(n)
     return source.enumerated().map {
-        (pair: (index: Int, elem: S.Iterator.Element)) in
+        (pair: (index: Int, elem: S.Element)) in
         isNth(pair.index+1)
             ? transform(pair.elem)
             : pair.elem