---

yaml
---
r: 323569
b: refs/heads/tensorflow-next
c: d38a72c
h: refs/heads/master
i:
  323567: af7c459

Author: jckarter

[refs]

@@ -1461,4 +1461,4 @@ refs/heads/master-rebranch: 86e95c23aa0d37f24ec138b7853146c1cead2e40
 refs/heads/rdar-53901732: 9bd06af3284e18a109cdbf9aa59d833b24eeca7b
 refs/heads/revert-26776-subst-always-returns-a-type: 1b8e18fdd391903a348970a4c848995d4cdd789c
 refs/heads/tensorflow-merge: 8b854f62f80d4476cb383d43c4aac2001dde3cec
-refs/heads/tensorflow-next: 91292710091d7783a1d500f3ad98c9f3240ae1a2
+refs/heads/tensorflow-next: d38a72c4ad6e98e60e221b66db055d1a490589b9

branches/tensorflow-next/CHANGELOG.md

@@ -26,27 +26,24 @@ CHANGELOG
 Swift Next
 ----------
 
-* [SR-8974][]:
+* [SR-4206][]:
 
-  Duplicate tuple element labels are no longer allowed, because it leads
-  to incorrect behavior. For example:
+  A method override is no longer allowed to have a generic signature with 
+  requirements not imposed by the base method. For example:
 
   ```
-  let dupLabels: (foo: Int, foo: Int) = (foo: 1, foo: 2)
-
-  enum Foo { case bar(x: Int, x: Int) }
-  let f: Foo = .bar(x: 0, x: 1)
+  protocol P {}
+  
+  class Base {
+    func foo<T>(arg: T) {}
+  }
+  
+  class Derived: Base {
+    override func foo<T: P>(arg: T) {}
+  }
   ```
 
-  will now be diagnosed as an error. 
-
-  Note: You can still use duplicate labels when declaring functions and
-  subscripts, as long as the internal labels are different. For example:
-
-  ```
-  func foo(bar x: Int, bar y: Int) {}
-  subscript(a x: Int, a y: Int) -> Int {}
-  ```
+  will now be diagnosed as an error.
 
 * [SR-6118][]:
 
@@ -68,6 +65,28 @@ Swift Next
 Swift 5.1
 ---------
 
+* [SR-8974][]:
+
+  Duplicate tuple element labels are no longer allowed, because it leads
+  to incorrect behavior. For example:
+
+  ```
+  let dupLabels: (foo: Int, foo: Int) = (foo: 1, foo: 2)
+
+  enum Foo { case bar(x: Int, x: Int) }
+  let f: Foo = .bar(x: 0, x: 1)
+  ```
+
+  will now be diagnosed as an error. 
+
+  Note: You can still use duplicate argument labels when declaring functions and
+  subscripts, as long as the internal parameter names are different. For example:
+
+  ```
+  func foo(bar x: Int, bar y: Int) {}
+  subscript(a x: Int, a y: Int) -> Int {}
+  ```
+
 * [SE-0244][]:
 
   Functions can now hide their concrete return type by declaring what protocols
@@ -7708,6 +7727,7 @@ Swift 1.0
 [SR-2608]: <https://bugs.swift.org/browse/SR-2608>
 [SR-2672]: <https://bugs.swift.org/browse/SR-2672>
 [SR-2688]: <https://bugs.swift.org/browse/SR-2688>
+[SR-4206]: <https://bugs.swift.org/browse/SR-4206>
 [SR-4248]: <https://bugs.swift.org/browse/SR-4248>
 [SR-5581]: <https://bugs.swift.org/browse/SR-5581>
 [SR-5719]: <https://bugs.swift.org/browse/SR-5719>

branches/tensorflow-next/benchmark/CMakeLists.txt

@@ -79,6 +79,7 @@ set(SWIFT_BENCH_MODULES
     single-source/DictionarySubscriptDefault
     single-source/DictionarySwap
     single-source/Diffing
+    single-source/DiffingMyers
     single-source/DropFirst
     single-source/DropLast
     single-source/DropWhile
@@ -105,7 +106,6 @@ set(SWIFT_BENCH_MODULES
     single-source/Memset
     single-source/MonteCarloE
     single-source/MonteCarloPi
-    single-source/Myers
     single-source/NSDictionaryCastToSwift
     single-source/NSError
     single-source/NSStringConversion

branches/tensorflow-next/benchmark/single-source/Diffing.swift

@@ -15,111 +15,55 @@ import TestsUtils
 let t: [BenchmarkCategory] = [.api]
 public let Diffing = [
   BenchmarkInfo(
-    name: "DiffSame",
-    runFunction: run_DiffSame,
+    name: "Diffing.Same",
+    runFunction: { diff($0, from: longPangram, to: longPangram) },
     tags: t,
-    legacyFactor: 10),
+    setUpFunction: { blackHole(longPangram) }),
   BenchmarkInfo(
-    name: "DiffPangramToAlphabet",
-    runFunction: run_DiffPangramToAlphabet,
+    name: "Diffing.PangramToAlphabet",
+    runFunction: { diff($0, from: longPangram, to: alphabets) },
     tags: t,
-    legacyFactor: 10),
+    setUpFunction: { blackHole((longPangram, alphabets)) }),
   BenchmarkInfo(
-    name: "DiffPangrams",
-    runFunction: run_DiffPangrams,
+    name: "Diffing.Pangrams",
+    runFunction: { diff($0, from:typingPangram, to: longPangram) },
     tags: t,
-    legacyFactor: 10),
+    setUpFunction: { blackHole((longPangram, typingPangram)) }),
   BenchmarkInfo(
-    name: "DiffReversedAlphabets",
-    runFunction: run_DiffReversedAlphabets,
+    name: "Diffing.ReversedAlphabets",
+    runFunction: { diff($0, from:alphabets, to: alphabetsReversed) },
     tags: t,
-    legacyFactor: 10),
+    setUpFunction: { blackHole((alphabets, alphabetsReversed)) }),
   BenchmarkInfo(
-    name: "DiffReversedLorem",
-    runFunction: run_DiffReversedLorem,
+    name: "Diffing.ReversedLorem",
+    runFunction: { diff($0, from: loremIpsum, to: loremReversed) },
     tags: t,
-    legacyFactor: 10),
+    setUpFunction: { blackHole((loremIpsum, loremReversed)) }),
   BenchmarkInfo(
-    name: "DiffDisparate",
-    runFunction: run_DiffDisparate,
+    name: "Diffing.Disparate",
+    runFunction: { diff($0, from: numbersAndSymbols, to: alphabets) },
     tags: t,
-    legacyFactor: 10),
+    setUpFunction: { blackHole((numbersAndSymbols, alphabets)) }),
   BenchmarkInfo(
-    name: "DiffSimilar",
-    runFunction: run_DiffSimilar,
+    name: "Diffing.Similar",
+    runFunction: { diff($0, from: unabridgedLorem, to: loremIpsum) },
     tags: t,
-    legacyFactor: 10),
+    setUpFunction: { blackHole((unabridgedLorem, loremIpsum)) }),
 ]
 
 let numbersAndSymbols = Array("0123456789`~!@#$%^&*()+=_-\"'?/<,>.\\{}'")
 let alphabets = Array("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
-let alphabetsReversed = Array("ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba")
+let alphabetsReversed = Array(alphabets.reversed())
 let longPangram = Array("This pangram contains four As, one B, two Cs, one D, thirty Es, six Fs, five Gs, seven Hs, eleven Is, one J, one K, two Ls, two Ms, eighteen Ns, fifteen Os, two Ps, one Q, five Rs, twenty-seven Ss, eighteen Ts, two Us, seven Vs, eight Ws, two Xs, three Ys, & one Z")
 let typingPangram = Array("The quick brown fox jumps over the lazy dog")
 let loremIpsum = Array("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.")
 let unabridgedLorem = Array("Lorem ipsum, quia dolor sit amet consectetur adipisci[ng] velit, sed quia non-numquam [do] eius modi tempora inci[di]dunt, ut labore et dolore magnam aliqua.")
-let loremReverse = Array(".auqila angam erolod te erobal tu tnudidicni ropmet domsuie od des ,tile gnicsipida rutetcesnoc ,tema tis rolod muspi meroL")
+let loremReversed = Array(loremIpsum.reversed())
 
-
-@inline(never)
-public func run_DiffSame(_ N: Int) {
-  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
-    for _ in 1...N {
-      let _ = longPangram.difference(from: longPangram)
-    }
-  }
-}
-
-@inline(never)
-public func run_DiffPangramToAlphabet(_ N: Int) {
-  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
-    for _ in 1...N {
-      let _ = longPangram.difference(from: alphabets)
-    }
-  }
-}
-
-@inline(never)
-public func run_DiffPangrams(_ N: Int) {
-  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
-    for _ in 1...N {
-      let _ = longPangram.difference(from: typingPangram)
-    }
-  }
-}
-
-@inline(never)
-public func run_DiffReversedAlphabets(_ N: Int) {
-  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
-    for _ in 1...N {
-      let _ = alphabets.difference(from: alphabetsReversed)
-    }
-  }
-}
-
-@inline(never)
-public func run_DiffReversedLorem(_ N: Int) {
-  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
-    for _ in 1...N {
-      let _ = loremIpsum.difference(from: loremReverse)
-    }
-  }
-}
-
-@inline(never)
-public func run_DiffDisparate(_ N: Int) {
-  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
-    for _ in 1...N {
-      let _ = alphabets.difference(from: numbersAndSymbols)
-    }
-  }
-}
-
-@inline(never)
-public func run_DiffSimilar(_ N: Int) {
+@inline(never) func diff(_ N: Int, from older: [Character], to newer: [Character]) {
   if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
     for _ in 1...N {
-      let _ = loremIpsum.difference(from: unabridgedLorem)
+      blackHole(newer.difference(from: older))
     }
   }
 }

branches/tensorflow-next/benchmark/single-source/Myers.swift renamed to branches/tensorflow-next/benchmark/single-source/DiffingMyers.swift

@@ -1,4 +1,4 @@
-//===--- Myers.swift -------------------------------------------===//
+//===--- DiffingMyers.swift -----------------------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -12,18 +12,25 @@
 
 import TestsUtils
 
-public let Myers = [
-  BenchmarkInfo(name: "Myers", runFunction: run_Myers, tags: [.algorithm]),
-]
+// The DiffingMyers test benchmarks Swift's performance running the algorithm
+// described in Myers (1986). The Diffing benchmark tracks the performance
+// of `Collection.difference(from:to:)`.
 
-let loremShort = Array("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.")
-let loremLong = Array("Sed ut perspiciatis, unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam eaque ipsa, quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt, explicabo. Nemo enim ipsam voluptatem, quia voluptas sit, aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos, qui ratione voluptatem sequi nesciunt, neque porro quisquam est, qui dolorem ipsum, quia dolor sit amet consectetur adipisci[ng] velit, sed quia non-numquam [do] eius modi tempora inci[di]dunt, ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum[d] exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit, qui in ea voluptate velit esse, quam nihil molestiae consequatur, vel illum, qui dolorem eum fugiat, quo voluptas nulla pariatur?")
+public let DiffingMyers = BenchmarkInfo(
+  name: "Diffing.Myers.Similar",
+  runFunction: run_Myers,
+  tags: [.algorithm],
+  setUpFunction: { blackHole((loremIpsum, unabridgedLorem)) })
+
+
+let loremIpsum = Array("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.")
+let unabridgedLorem = Array("Lorem ipsum, quia dolor sit amet consectetur adipisci[ng] velit, sed quia non-numquam [do] eius modi tempora inci[di]dunt, ut labore et dolore magnam aliqua.")
 
 @inline(never)
 public func run_Myers(N: Int) {
   if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
     for _ in 1...N {
-      let _ = myers(from: loremShort, to: loremLong, using: ==)
+      blackHole(myers(from: unabridgedLorem, to: loremIpsum, using: ==))
     }
   }
 }
@@ -193,4 +200,4 @@ fileprivate func myers<C,D>(
       return CollectionDifference(_formChanges(from: a, to: b, using:_descent(from: a, to: b)))!
     }
   }
-}
+}

branches/tensorflow-next/benchmark/utils/main.swift

@@ -67,6 +67,7 @@ import DictionaryRemove
 import DictionarySubscriptDefault
 import DictionarySwap
 import Diffing
+import DiffingMyers
 import DropFirst
 import DropLast
 import DropWhile
@@ -93,7 +94,6 @@ import MapReduce
 import Memset
 import MonteCarloE
 import MonteCarloPi
-import Myers
 import NibbleSort
 import NIOChannelPipeline
 import NSDictionaryCastToSwift
@@ -243,6 +243,7 @@ registerBenchmark(DictionaryRemove)
 registerBenchmark(DictionarySubscriptDefault)
 registerBenchmark(DictionarySwap)
 registerBenchmark(Diffing)
+registerBenchmark(DiffingMyers)
 registerBenchmark(DropFirst)
 registerBenchmark(DropLast)
 registerBenchmark(DropWhile)
@@ -270,7 +271,6 @@ registerBenchmark(MapReduce)
 registerBenchmark(Memset)
 registerBenchmark(MonteCarloE)
 registerBenchmark(MonteCarloPi)
-registerBenchmark(Myers)
 registerBenchmark(NSDictionaryCastToSwift)
 registerBenchmark(NSErrorTest)
 #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)

branches/tensorflow-next/cmake/modules/AddSwift.cmake

@@ -1512,10 +1512,9 @@ function(add_swift_host_library name)
 
   if(NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
     swift_install_in_component(TARGETS ${name}
-                               ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}
-                               LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
-                               RUNTIME DESTINATION bin
-                               COMPONENT dev)
+      ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX} COMPONENT dev
+      LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX} COMPONENT dev
+      RUNTIME DESTINATION bin COMPONENT dev)
   endif()
 
   swift_is_installing_component(dev is_installing)
@@ -2139,10 +2138,15 @@ function(add_swift_target_library name)
 
       if(sdk STREQUAL WINDOWS AND CMAKE_SYSTEM_NAME STREQUAL Windows)
         swift_install_in_component(TARGETS ${name}-windows-${SWIFT_PRIMARY_VARIANT_ARCH}
-                                   RUNTIME DESTINATION "bin"
-                                   LIBRARY DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/${resource_dir}/${resource_dir_sdk_subdir}/${SWIFT_PRIMARY_VARIANT_ARCH}"
-                                   ARCHIVE DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/${resource_dir}/${resource_dir_sdk_subdir}/${SWIFT_PRIMARY_VARIANT_ARCH}"
-                                   COMPONENT "${SWIFTLIB_INSTALL_IN_COMPONENT}"
+                                   RUNTIME
+                                     DESTINATION "bin"
+                                     COMPONENT "${SWIFTLIB_INSTALL_IN_COMPONENT}"
+                                   LIBRARY
+                                     DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/${resource_dir}/${resource_dir_sdk_subdir}/${SWIFT_PRIMARY_VARIANT_ARCH}"
+                                     COMPONENT "${SWIFTLIB_INSTALL_IN_COMPONENT}"
+                                   ARCHIVE
+                                     DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/${resource_dir}/${resource_dir_sdk_subdir}/${SWIFT_PRIMARY_VARIANT_ARCH}"
+                                     COMPONENT "${SWIFTLIB_INSTALL_IN_COMPONENT}"
                                    PERMISSIONS ${file_permissions})
       else()
         swift_install_in_component(FILES "${UNIVERSAL_LIBRARY_NAME}"
@@ -2423,8 +2427,9 @@ function(add_swift_host_tool executable)
     ${ASHT_UNPARSED_ARGUMENTS})
 
   swift_install_in_component(TARGETS ${executable}
-                             RUNTIME DESTINATION bin
-                             COMPONENT ${ASHT_SWIFT_COMPONENT})
+                             RUNTIME
+                               DESTINATION bin
+                               COMPONENT ${ASHT_SWIFT_COMPONENT})
 
   swift_is_installing_component(${ASHT_SWIFT_COMPONENT} is_installing)
 

branches/tensorflow-next/docs/SIL.rst

@@ -5110,13 +5110,15 @@ cond_fail
 `````````
 ::
 
-  sil-instruction ::= 'cond_fail' sil-operand
+  sil-instruction ::= 'cond_fail' sil-operand, string-literal
 
-  cond_fail %0 : $Builtin.Int1
+  cond_fail %0 : $Builtin.Int1, "failure reason"
   // %0 must be of type $Builtin.Int1
 
 This instruction produces a `runtime failure`_ if the operand is one.
 Execution proceeds normally if the operand is zero.
+The second operand is a static failure message, which is displayed by the
+debugger in case the failure is triggered.
 
 Terminators
 ~~~~~~~~~~~

branches/tensorflow-next/docs/StandardLibraryProgrammersManual.md

@@ -50,6 +50,19 @@ TODO: Should this subsume or link to [AccessControlInStdlib.rst](https://github.
 
 Optionals can be unwrapped with `!`, which triggers a trap on nil. Alternatively, they can be `.unsafelyUnwrapped()`, which will check and trap in debug builds of user code. Internal to the standard library is `._unsafelyUnwrappedUnchecked()` which will only check and trap in debug builds of the standard library itself. These correspond directly with `_precondition`, `_debugPrecondition`, and `_sanityCheck`. See [that section](#precondition) for details.
 
+#### UnsafeBitCast and Casting References
+
+In general `unsafeBitCast` should be avoided because it's correctness relies on subtle assumptions that will never be enforced, and it indicates a bug in Swift's type system that should be fixed. It's less bad for non-pointer trivial types. Pointer casting should go through one of the memory binding API instead as a last resort.
+
+Reference casting is more interesting. References casting can include converting to an Optional reference and converting from a class constrained existential.
+
+The regular `as` operator should be able to convert between reference types with full dynamic checking.
+
+`unsafeDownCast` is just as capable, but is only dynamically checked in debug mode or if the cast requires runtime support.
+
+`_unsafeUncheckedDowncast` is the same but is only dynamically checked in the stdlib asserts build, or if the cast requires runtime support.
+
+`_unsafeReferenceCast` is only dynamically checked if the cast requires runtime support. Additionally, it does not impose any static `AnyObject` constraint on the incoming reference. This is useful in a generic context where the object-ness can be determined dynamically, as done in some bridged containers.
 
 ### Builtins