---

yaml
---
r: 318429
b: refs/heads/master-rebranch
c: ab857ba
h: refs/heads/master
i:
  318427: c89cab1

Author: swift-ci

[refs]

@@ -1457,4 +1457,4 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-02-a: ddd2b2976aa9bfde5f20fe37f6bd2
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-03-a: 171cc166f2abeb5ca2a4003700a8a78a108bd300
 refs/heads/benlangmuir-patch-1: baaebaf39d52f3bf36710d4fe40cf212e996b212
 refs/heads/i-do-redeclare: 8c4e6d5de5c1e3f0a2cedccf319df713ea22c48e
-refs/heads/master-rebranch: 90c188bab7306542a3edd79df2696d0807516f8e
+refs/heads/master-rebranch: ab857ba4c7ea0cb4e2a321a53e500d4809c94c42

branches/master-rebranch/docs/StandardLibraryProgrammersManual.md

@@ -171,6 +171,65 @@ The standard library utilizes thread local storage (TLS) to cache expensive comp
 
 See [ThreadLocalStorage.swift](https://github.com/apple/swift/blob/master/stdlib/public/core/ThreadLocalStorage.swift) for more details.
 
+
+## Working with Resilience
+
+Maintaining ABI compatibility with previously released versions of the standard library makes things more complicated. This section details some of the extra rules to remember and patterns to use.
+
+### The Curiously Recursive Inlinable Switch Pattern (CRISP)
+
+When inlinable code switches over a non-frozen enum, it has to handle possible future cases (since it will be inlined into a module outside the standard library). You can see this in action with the implementation of `round(_:)` in FloatingPointTypes.swift.gyb, which takes a FloatingPointRoundingRule. It looks something like this:
+
+```swift
+@_transparent
+public mutating func round(_ rule: FloatingPointRoundingRule) {
+  switch rule {
+  case .toNearestOrAwayFromZero:
+    _value = Builtin.int_round_FPIEEE${bits}(_value)
+  case .toNearestOrEven:
+    _value = Builtin.int_rint_FPIEEE${bits}(_value)
+  // ...
+  @unknown default:
+    self._roundSlowPath(rule)
+  }
+}
+```
+
+Making `round(_:)` inlinable but still have a default case is an attempt to get the best of both worlds: if the rounding rule is known at compile time, the call will compile down to a single instruction in optimized builds; and if it dynamically turns out to be a new kind of rounding rule added in Swift 25 (e.g. `.towardFortyTwo`), there's a fallback function, `_roundSlowPath(_:)`, that can handle it.
+
+So what does `_roundSlowPath(_:)` look like? Well, it can't be inlinable, because that would defeat the purpose. It *could* just look like this:
+
+```swift
+@usableFromInline
+internal mutating func _roundSlowPath(_ rule: FloatingPointRoundingRule) {
+  switch rule {
+  case .toNearestOrAwayFromZero:
+    _value = Builtin.int_round_FPIEEE${bits}(_value)
+  case .toNearestOrEven:
+    _value = Builtin.int_rint_FPIEEE${bits}(_value)
+  // ...
+  }
+}
+```
+
+...i.e. exactly the same as `round(_:)` but with no `default` case. That's guaranteed to be up to date if any new cases are added in the future. But it seems a little silly, since it's duplicating code that's in `round(_:)`. We *could* omit cases that have always existed, but there's a better answer:
+
+```swift
+// Slow path for new cases that might have been inlined into an old
+// ABI-stable version of round(_:) called from a newer version. If this is
+// the case, this non-inlinable function will call into the _newer_ version
+// which _will_ support this rounding rule.
+@usableFromInline
+internal mutating func _roundSlowPath(_ rule: FloatingPointRoundingRule) {
+  self.round(rule)
+}
+```
+
+Because `_roundSlowPath(_:)` isn't inlinable, the version of `round(_:)` that gets called at run time will always be the version implemented in the standard library dylib. And since FloatingPointRoundingRule is *also* defined in the standard library, we know it'll never be out of sync with this version of `round(_:)`.
+
+Maybe some day we'll have special syntax in the language to say "call this method without allowing inlining" to get the same effect, but for now, this Curiously Recursive Inlinable Switch Pattern allows for safe inlining of switches over non-frozen enums with less boilerplate than you might otherwise have. Not none, but less.
+
+
 ## Productivity Hacks
 
 ### Be a Ninja

branches/master-rebranch/stdlib/public/core/Character.swift

@@ -81,6 +81,10 @@ extension Character {
   internal func _invariantCheck() {
     _internalInvariant(_str.count == 1)
     _internalInvariant(_str._guts.isFastUTF8)
+
+    // TODO(@eject): Switch to a helper property on StringObject/StringGuts.
+    _internalInvariant(
+      _str._guts.isSmall || _str._guts._object._countAndFlags.isTailAllocated)
   }
   #endif // INTERNAL_CHECKS_ENABLED
 }
@@ -173,7 +177,17 @@ extension Character :
       "Can't form a Character from an empty String")
     _debugPrecondition(s.index(after: s.startIndex) == s.endIndex,
       "Can't form a Character from a String containing more than one extended grapheme cluster")
-    self.init(unchecked: s)
+
+    // TODO(@eject): Switch to a helper property on StringObject/StringGuts.
+    if _fastPath(
+      s._guts.isSmall || s._guts._object._countAndFlags.isTailAllocated
+    ) {
+      self.init(unchecked: s)
+      return
+    }
+
+    // TODO(@eject): Outline this
+    self.init(unchecked: s._withUTF8 { String._uncheckedFromUTF8($0) })
   }
 }
 

branches/master-rebranch/stdlib/public/core/StringObject.swift

@@ -617,9 +617,10 @@ extension _StringObject {
  isNativelyStored: set for native stored strings
    - `largeAddressBits` holds an instance of `_StringStorage`.
    - I.e. the start of the code units is at the stored address + `nativeBias`
- isTailAllocated: start of the code units is at the stored address + `nativeBias`
+ isTailAllocated: contiguous UTF-8 code units starts at address + `nativeBias`
    - `isNativelyStored` always implies `isTailAllocated`, but not vice versa
       (e.g. literals)
+   - `isTailAllocated` always implies `isFastUTF8`
  TBD: Reserved for future usage
    - Setting a TBD bit to 1 must be semantically equivalent to 0
    - I.e. it can only be used to "cache" fast-path information in the future
@@ -1073,6 +1074,9 @@ extension _StringObject {
     } else {
       _internalInvariant(isLarge)
       _internalInvariant(largeCount == count)
+      if _countAndFlags.isTailAllocated {
+        _internalInvariant(providesFastUTF8)
+      }
       if providesFastUTF8 && largeFastIsTailAllocated {
         _internalInvariant(!isSmall)
         _internalInvariant(!largeIsCocoa)

branches/master-rebranch/test/stdlib/StringBridge.swift

@@ -75,5 +75,29 @@ StringBridgeTests.test("Tagged NSString") {
 #endif // not 32bit
 }
 
+func returnOne<T>(_ t: T) -> Int { return 1 }
+StringBridgeTests.test("Character from NSString") {
+  // NOTE: Using hard-coded literals to directly construct NSStrings
+  let ns1 = "A" as NSString
+  let ns2 = "A\u{301}" as NSString
+  let ns3 = "𓁹͇͈͉͍͎͊͋͌ͧͨͩͪͫͬͭͮ͏̛͓͔͕͖͙͚̗̘̙̜̹̺̻̼͐͑͒͗͛ͣͤͥͦ̽̾̿̀́͂̓̈́͆ͧͨͩͪͫͬͭͮ͘̚͜͟͢͝͞͠͡ͅ" as NSString
+
+  let c1 = Character(ns1 as String)
+  let c2 = Character(ns2 as String)
+  let c3 = Character(ns3 as String)
+
+  expectEqual("A", String(c1))
+  expectNotNil(String(c1).utf8.withContiguousStorageIfAvailable(returnOne))
+
+  expectEqual("A\u{301}", String(c2))
+  expectNotNil(String(c2).utf8.withContiguousStorageIfAvailable(returnOne))
+  expectNil((ns2 as String).utf8.withContiguousStorageIfAvailable(returnOne))
+
+  expectEqual("𓁹͇͈͉͍͎͊͋͌ͧͨͩͪͫͬͭͮ͏̛͓͔͕͖͙͚̗̘̙̜̹̺̻̼͐͑͒͗͛ͣͤͥͦ̽̾̿̀́͂̓̈́͆ͧͨͩͪͫͬͭͮ͘̚͜͟͢͝͞͠͡ͅ", String(c3))
+  expectNotNil(String(c3).utf8.withContiguousStorageIfAvailable(returnOne))
+  expectNil((ns3 as String).utf8.withContiguousStorageIfAvailable(returnOne))
+}
+
+
 runAllTests()