Inline all the new low-level bits

Author: Dave Abrahams

stdlib/public/core/UTF8.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 extension _Unicode {
+  @_fixed_layout
   public enum UTF8 {
   case _swift3Buffer(_Unicode.UTF8.ForwardParser)
   }
@@ -23,10 +24,14 @@ extension _Unicode.UTF8 : UnicodeEncoding {
     return EncodedScalar(_storage: 0xbdbfef, _bitCount: 24)
   }
 
+  @inline(__always)
+  @_inlineable
   public static func _isScalar(_ x: CodeUnit) -> Bool {
     return x & 0x80 == 0
   }
 
+  @inline(__always)
+  @_inlineable
   public static func decode(_ source: EncodedScalar) -> UnicodeScalar {
     let bits = source._storage
     switch source._bitCount {
@@ -51,6 +56,8 @@ extension _Unicode.UTF8 : UnicodeEncoding {
     }
   }
 
+  @inline(__always)
+  @_inlineable
   public static func encode(_ source: UnicodeScalar) -> EncodedScalar {
     var c = source.value
     if _fastPath(c < (1&<<7)) {
@@ -80,20 +87,25 @@ extension _Unicode.UTF8 : UnicodeEncoding {
 
   public struct ForwardParser {
     public typealias _Buffer = _UIntBuffer<UInt32, UInt8>
+    @inline(__always)
+    @_inlineable
     public init() { _buffer = _Buffer() }
     public var _buffer: _Buffer
   }
 
   public struct ReverseParser {
     public typealias _Buffer = _UIntBuffer<UInt32, UInt8>
+    @inline(__always)
+    @_inlineable
     public init() { _buffer = _Buffer() }
     public var _buffer: _Buffer
   }
 }
 
 extension UTF8.ReverseParser : UnicodeParser, _UTFParser {
   public typealias Encoding = _Unicode.UTF8
-
+  @inline(__always)
+  @_inlineable
   public func _parseMultipleCodeUnits() -> (isValid: Bool, bitCount: UInt8) {
     _sanityCheck(_buffer._storage & 0x80 != 0) // this case handled elsewhere
     if _buffer._storage                & 0b0__1110_0000__1100_0000
@@ -128,6 +140,7 @@ extension UTF8.ReverseParser : UnicodeParser, _UTFParser {
   /// Returns the length of the invalid sequence that ends with the LSB of
   /// buffer.
   @inline(never)
+  @_versioned
   func _invalidLength() -> UInt8 {
     if _buffer._storage                 & 0b0__1111_0000__1100_0000
                                        == 0b0__1110_0000__1000_0000 {
@@ -156,6 +169,8 @@ extension UTF8.ReverseParser : UnicodeParser, _UTFParser {
     return 1
   }
 
+  @inline(__always)
+  @_inlineable
   public func _bufferedScalar(bitCount: UInt8) -> Encoding.EncodedScalar {
     return Encoding.EncodedScalar(
       _storage: _buffer._storage.byteSwapped &>> (32 - bitCount),
@@ -166,7 +181,9 @@ extension UTF8.ReverseParser : UnicodeParser, _UTFParser {
 
 extension _Unicode.UTF8.ForwardParser : UnicodeParser, _UTFParser {
   public typealias Encoding = _Unicode.UTF8
-  
+
+  @inline(__always)
+  @_inlineable
   public func _parseMultipleCodeUnits() -> (isValid: Bool, bitCount: UInt8) {
     _sanityCheck(_buffer._storage & 0x80 != 0) // this case handled elsewhere
 
@@ -201,6 +218,7 @@ extension _Unicode.UTF8.ForwardParser : UnicodeParser, _UTFParser {
   /// Returns the length of the invalid sequence that starts with the LSB of
   /// buffer.
   @inline(never)
+  @_versioned
   func _invalidLength() -> UInt8 {
     if _buffer._storage               & 0b0__1100_0000__1111_0000
                                      == 0b0__1000_0000__1110_0000 {

stdlib/public/core/UnicodeParser.swift

@@ -70,6 +70,8 @@ extension _Unicode {
     CodeUnitIterator : IteratorProtocol, 
     Parser: UnicodeParser
   > where Parser.Encoding.CodeUnit == CodeUnitIterator.Element {
+    @inline(__always)
+    @_inlineable
     public init(codeUnits: CodeUnitIterator, parser: Parser) {
       self.codeUnits = codeUnits
       self.parser = parser
@@ -80,6 +82,8 @@ extension _Unicode {
 }
 
 extension _Unicode.ParsingIterator : IteratorProtocol, Sequence {
+  @inline(__always)
+  @_inlineable
   public mutating func next() -> Parser.Encoding.EncodedScalar? {
     switch parser.parseScalar(from: &codeUnits) {
     case let .valid(scalarContent): return scalarContent