[string] Less inlining for code size.

Less inlining for hashing and comparison. Saves code size on very
frequent String comparison in exchange for costing us in some of our
ridiculuous micro-benchmarks.

Also adds in more _effects for better codegen

Author: milseman

stdlib/public/core/StringComparable.swift

@@ -68,15 +68,15 @@ extension String : Equatable {
   @inlinable @inline(__always) // For the bitwise comparision
   @_effects(readonly)
   public static func == (lhs: String, rhs: String) -> Bool {
-    return _stringCompare(lhs._guts, nil, rhs._guts, nil, expecting: .equal)
+    return _stringCompare(lhs._guts, rhs._guts, expecting: .equal)
   }
 }
 
 extension String : Comparable {
   @inlinable @inline(__always) // For the bitwise comparision
   @_effects(readonly)
   public static func < (lhs: String, rhs: String) -> Bool {
-    return _stringCompare(lhs._guts, nil, rhs._guts, nil, expecting: .less)
+    return _stringCompare(lhs._guts, rhs._guts, expecting: .less)
   }
 }
 

stdlib/public/core/StringComparison.swift

@@ -13,11 +13,42 @@
 import SwiftShims
 
 
-@inlinable @inline(__always) // Fold away opt range and top-level fast-paths
+@usableFromInline
 @_effects(readonly)
 internal func _stringCompare(
-  _ lhs: _StringGuts, _ lhsRange: Range<Int>?,
-  _ rhs: _StringGuts, _ rhsRange: Range<Int>?,
+  _ lhs: _StringGuts, _ rhs: _StringGuts,
+  expecting: _StringComparisonResult
+) -> Bool {
+  _sanityCheck(expecting == .equal || expecting == .less)
+  if lhs.rawBits == rhs.rawBits {
+    return expecting == .equal
+  }
+  if _fastPath(lhs.isFastUTF8 && rhs.isFastUTF8) {
+    let isNFC = lhs.isNFC && rhs.isNFC
+    return lhs.withFastUTF8 { utf8Left in
+      return rhs.withFastUTF8 { utf8Right in
+        if isNFC {
+          let cmp = _binaryCompare(utf8Left, utf8Right)
+          if expecting == .equal {
+            return cmp == 0
+          }
+          _sanityCheck(expecting == .less)
+          return cmp < 0
+        }
+
+        return _stringCompare(utf8Left, utf8Right, expecting: expecting)
+      }
+    }
+  }
+  return _stringCompareSlow(
+    lhs, 0..<lhs.count, rhs, 0..<rhs.count, expecting: expecting)
+}
+
+@usableFromInline
+@_effects(readonly)
+internal func _stringCompare(
+  _ lhs: _StringGuts, _ lhsRange: Range<Int>,
+  _ rhs: _StringGuts, _ rhsRange: Range<Int>,
   expecting: _StringComparisonResult
 ) -> Bool {
   _sanityCheck(expecting == .equal || expecting == .less)

stdlib/public/core/StringHashable.swift

@@ -18,7 +18,6 @@ extension String : Hashable {
   ///
   /// - Parameter hasher: The hasher to use when combining the components
   ///   of this instance.
-  @inlinable // For pre-normal fast paths
   public func hash(into hasher: inout Hasher) {
     if _fastPath(self._guts.isNFCFastUTF8) {
       self._guts.withFastUTF8 {
@@ -38,7 +37,8 @@ extension StringProtocol {
   ///
   /// - Parameter hasher: The hasher to use when combining the components
   ///   of this instance.
-  @inlinable
+  @_specialize(where Self == String)
+  @_specialize(where Self == Substring)
   public func hash(into hasher: inout Hasher) {
     _gutsSlice._normalizedHash(into: &hasher)
   }

stdlib/public/core/StringObject.swift

@@ -1020,9 +1020,9 @@ extension _StringObject {
     return sharedStorage.start
   }
 
-  @inlinable
+  @usableFromInline
   internal var sharedUTF8: UnsafeBufferPointer<UInt8> {
-    @inline(__always) get {
+    @_effects(releasenone) @inline(never) get {
       _sanityCheck(largeFastIsShared)
       let start = self.getSharedUTF8Start()
       return UnsafeBufferPointer(start: start, count: largeCount)
@@ -1121,22 +1121,21 @@ extension _StringObject {
   internal var fastUTF8: UnsafeBufferPointer<UInt8> {
     @inline(__always) get {
       _sanityCheck(self.isLarge && self.providesFastUTF8)
-      let start: UnsafePointer<UInt8>
-      let count = self.largeCount
       if _slowPath(self.largeFastIsShared) {
-        start = getSharedUTF8Start()
-      } else {
-        start = self.nativeUTF8Start
+        return sharedUTF8
       }
-      return UnsafeBufferPointer(start: start, count: count)
+      return UnsafeBufferPointer(
+        start: self.nativeUTF8Start, count: self.largeCount)
     }
   }
 
   // Whether the object stored can be bridged directly as a NSString
   @usableFromInline // @opaque
   internal var hasObjCBridgeableObject: Bool {
-    // Currently, all mortal objects can zero-cost bridge
-    return !self.isImmortal
+    @_effects(releasenone) get {
+      // Currently, all mortal objects can zero-cost bridge
+      return !self.isImmortal
+    }
   }
 
   // Fetch the stored subclass of NSString for bridging