[gardening] Clean up many String computed vars

stdlib/public/core/SmallString.swift

@@ -32,10 +32,8 @@ internal struct _SmallString {
   @usableFromInline
   internal var _storage: RawBitPattern
 
-  @inlinable
-  internal var rawBits: RawBitPattern {
-    @inline(__always) get { return _storage }
-  }
+  @inlinable @inline(__always)
+  internal var rawBits: RawBitPattern { return _storage }
 
   @inlinable
   internal var leadingRawBits: UInt64 {
@@ -76,15 +74,13 @@ internal struct _SmallString {
 }
 
 extension _SmallString {
-  @inlinable
+  @inlinable @inline(__always)
   internal static var capacity: Int {
-    @inline(__always) get {
 #if arch(i386) || arch(arm)
-      return 10
+    return 10
 #else
-      return 15
+    return 15
 #endif
-    }
   }
 
   // Get an integer equivalent to the _StringObject.discriminatedObjectRawBits
@@ -95,30 +91,20 @@ extension _SmallString {
     return _storage.1.littleEndian
   }
 
-  @inlinable
-  internal var capacity: Int {
-    @inline(__always) get {
-      return _SmallString.capacity
-    }
-  }
+  @inlinable @inline(__always)
+  internal var capacity: Int { return _SmallString.capacity }
 
-  @inlinable
+  @inlinable @inline(__always)
   internal var count: Int {
-    @inline(__always) get {
-      return _StringObject.getSmallCount(fromRaw: rawDiscriminatedObject)
-    }
+    return _StringObject.getSmallCount(fromRaw: rawDiscriminatedObject)
   }
 
-  @inlinable
-  internal var unusedCapacity: Int {
-    @inline(__always) get { return capacity &- count }
-  }
+  @inlinable @inline(__always)
+  internal var unusedCapacity: Int { return capacity &- count }
 
-  @inlinable
+  @inlinable @inline(__always)
   internal var isASCII: Bool {
-    @inline(__always) get {
-      return _StringObject.getSmallIsASCII(fromRaw: rawDiscriminatedObject)
-    }
+    return _StringObject.getSmallIsASCII(fromRaw: rawDiscriminatedObject)
   }
 
   // Give raw, nul-terminated code units. This is only for limited internal
@@ -170,11 +156,11 @@ extension _SmallString: RandomAccessCollection, MutableCollection {
   @usableFromInline
   internal typealias SubSequence = _SmallString
 
-  @inlinable
-  internal var startIndex: Int { @inline(__always) get { return 0 } }
+  @inlinable @inline(__always)
+  internal var startIndex: Int { return 0 }
 
-  @inlinable
-  internal var endIndex: Int { @inline(__always) get { return count } }
+  @inlinable @inline(__always)
+  internal var endIndex: Int { return count }
 
   @inlinable
   internal subscript(_ idx: Int) -> UInt8 {
@@ -196,15 +182,12 @@ extension _SmallString: RandomAccessCollection, MutableCollection {
     }
   }
 
-  @inlinable // FIXME(inline-always) was usableFromInline
-  // testable
+  @inlinable  @inline(__always)
   internal subscript(_ bounds: Range<Index>) -> SubSequence {
-    @inline(__always) get {
-      // TODO(String performance): In-vector-register operation
-      return self.withUTF8 { utf8 in
-        let rebased = UnsafeBufferPointer(rebasing: utf8[bounds])
-        return _SmallString(rebased)._unsafelyUnwrappedUnchecked
-      }
+    // TODO(String performance): In-vector-register operation
+    return self.withUTF8 { utf8 in
+      let rebased = UnsafeBufferPointer(rebasing: utf8[bounds])
+      return _SmallString(rebased)._unsafelyUnwrappedUnchecked
     }
   }
 }

stdlib/public/core/StringCharacterView.swift

@@ -35,25 +35,20 @@ extension String: BidirectionalCollection {
   /// The position of the first character in a nonempty string.
   ///
   /// In an empty string, `startIndex` is equal to `endIndex`.
-  @inlinable
-  public var startIndex: Index {
-    @inline(__always) get { return _guts.startIndex }
-  }
+  @inlinable @inline(__always)
+  public var startIndex: Index { return _guts.startIndex }
 
   /// A string's "past the end" position---that is, the position one greater
   /// than the last valid subscript argument.
   ///
   /// In an empty string, `endIndex` is equal to `startIndex`.
-  @inlinable
-  public var endIndex: Index {
-    @inline(__always) get { return _guts.endIndex }
-  }
+  @inlinable @inline(__always)
+  public var endIndex: Index { return _guts.endIndex }
 
   /// The number of characters in a string.
+  @inline(__always)
   public var count: Int {
-    @inline(__always) get {
-      return distance(from: startIndex, to: endIndex)
-    }
+    return distance(from: startIndex, to: endIndex)
   }
 
   /// Returns the position immediately after the given index.
@@ -190,16 +185,14 @@ extension String: BidirectionalCollection {
   ///
   /// - Parameter i: A valid index of the string. `i` must be less than the
   ///   string's end index.
-  @inlinable
+  @inlinable @inline(__always)
   public subscript(i: Index) -> Character {
-    @inline(__always) get {
-      _boundsCheck(i)
+    _boundsCheck(i)
 
-      let i = _guts.scalarAlign(i)
-      let distance = _characterStride(startingAt: i)
-      return _guts.errorCorrectedCharacter(
-        startingAt: i._encodedOffset, endingAt: i._encodedOffset &+ distance)
-    }
+    let i = _guts.scalarAlign(i)
+    let distance = _characterStride(startingAt: i)
+    return _guts.errorCorrectedCharacter(
+      startingAt: i._encodedOffset, endingAt: i._encodedOffset &+ distance)
   }
 
   @inlinable @inline(__always)

stdlib/public/core/StringGuts.swift

@@ -37,9 +37,9 @@ struct _StringGuts {
 
 // Raw
 extension _StringGuts {
-  @inlinable
+  @inlinable @inline(__always)
   internal var rawBits: _StringObject.RawBitPattern {
-    @inline(__always) get { return _object.rawBits }
+    return _object.rawBits
   }
 }
 
@@ -78,34 +78,33 @@ extension _StringGuts {
 // Queries
 extension _StringGuts {
   // The number of code units
-  @inlinable
-  internal var count: Int { @inline(__always) get { return _object.count } }
+  @inlinable @inline(__always)
+  internal var count: Int { return _object.count }
 
-  @inlinable
-  internal var isEmpty: Bool { @inline(__always) get { return count == 0 } }
+  @inlinable @inline(__always)
+  internal var isEmpty: Bool { return count == 0 }
 
-  @inlinable
-  internal var isSmall: Bool {
-    @inline(__always) get { return _object.isSmall }
-  }
+  @inlinable @inline(__always)
+  internal var isSmall: Bool { return _object.isSmall }
 
+  @inline(__always)
   internal var isSmallASCII: Bool {
-    @inline(__always) get { return _object.isSmall && _object.smallIsASCII }
+    return _object.isSmall && _object.smallIsASCII
   }
 
-  @inlinable
+  @inlinable @inline(__always)
   internal var asSmall: _SmallString {
-    @inline(__always) get { return _SmallString(_object) }
+    return _SmallString(_object)
   }
 
-  @inlinable
+  @inlinable @inline(__always)
   internal var isASCII: Bool  {
-    @inline(__always) get { return _object.isASCII }
+    return _object.isASCII
   }
 
-  @inlinable
+  @inlinable @inline(__always)
   internal var isFastASCII: Bool  {
-    @inline(__always) get { return isFastUTF8 && _object.isASCII }
+    return isFastUTF8 && _object.isASCII
   }
 
   @inline(__always)
@@ -134,9 +133,9 @@ extension _StringGuts {
   internal var isFastUTF8: Bool { return _fastPath(_object.providesFastUTF8) }
 
   // A String which does not provide fast access to contiguous UTF-8 code units
-  @inlinable
+  @inlinable @inline(__always)
   internal var isForeign: Bool {
-    @inline(__always) get { return _slowPath(_object.isForeign) }
+     return _slowPath(_object.isForeign)
   }
 
   @inlinable @inline(__always)
@@ -259,11 +258,10 @@ extension _StringGuts {
     return numWritten
   }
 
+  @inline(__always)
   internal var utf8Count: Int {
-    @inline(__always) get {
-      if _fastPath(self.isFastUTF8) { return count }
-      return String(self).utf8.count
-    }
+    if _fastPath(self.isFastUTF8) { return count }
+    return String(self).utf8.count
   }
 }
 
@@ -272,13 +270,13 @@ extension _StringGuts {
   @usableFromInline
   internal typealias Index = String.Index
 
-  @inlinable
+  @inlinable @inline(__always)
   internal var startIndex: String.Index {
-    @inline(__always) get { return Index(_encodedOffset: 0) }
+   return Index(_encodedOffset: 0)
   }
-  @inlinable
+  @inlinable @inline(__always)
   internal var endIndex: String.Index {
-    @inline(__always) get { return Index(_encodedOffset: self.count) }
+    return Index(_encodedOffset: self.count)
   }
 }
 

stdlib/public/core/StringIndex.swift

@@ -49,18 +49,13 @@ extension String {
 }
 
 extension String.Index {
-  @inlinable
-  internal var orderingValue: UInt64 {
-    // TODO(String micro-performance): Consider mask instead of shift
-    @inline(__always) get { return _rawBits &>> 14 }
-  }
+  @inlinable @inline(__always)
+  internal var orderingValue: UInt64 { return _rawBits &>> 14 }
 
   // Whether this is at the canonical "start" position, that is encoded AND
   // transcoded offset of 0.
-  @inlinable
-  internal var isZeroPosition: Bool {
-    @inline(__always) get { return orderingValue == 0 }
-  }
+  @inlinable @inline(__always)
+  internal var isZeroPosition: Bool { return orderingValue == 0 }
 
   /// The UTF-16 code unit offset corresponding to this Index
   public func utf16Offset<S: StringProtocol>(in s: S) -> Int {
@@ -80,11 +75,9 @@ extension String.Index {
     return Int(truncatingIfNeeded: _rawBits &>> 16)
   }
 
-  @inlinable
+  @inlinable @inline(__always)
   internal var transcodedOffset: Int {
-    @inline(__always) get {
-      return Int(truncatingIfNeeded: orderingValue & 0x3)
-    }
+    return Int(truncatingIfNeeded: orderingValue & 0x3)
   }
 
   @usableFromInline
@@ -164,45 +157,35 @@ extension String.Index {
 // Creation helpers, which will make migration easier if we decide to use and
 // propagate the reserved bits.
 extension String.Index {
-  @inlinable
+  @inlinable @inline(__always)
   internal var strippingTranscoding: String.Index {
-    @inline(__always) get {
-      return String.Index(_encodedOffset: self._encodedOffset)
-    }
+    return String.Index(_encodedOffset: self._encodedOffset)
   }
 
-  @inlinable
+  @inlinable @inline(__always)
   internal var nextEncoded: String.Index {
-    @inline(__always) get {
-      _internalInvariant(self.transcodedOffset == 0)
-      return String.Index(_encodedOffset: self._encodedOffset &+ 1)
-    }
+    _internalInvariant(self.transcodedOffset == 0)
+    return String.Index(_encodedOffset: self._encodedOffset &+ 1)
   }
 
-  @inlinable
+  @inlinable @inline(__always)
   internal var priorEncoded: String.Index {
-    @inline(__always) get {
-      _internalInvariant(self.transcodedOffset == 0)
-      return String.Index(_encodedOffset: self._encodedOffset &- 1)
-    }
+    _internalInvariant(self.transcodedOffset == 0)
+    return String.Index(_encodedOffset: self._encodedOffset &- 1)
   }
 
-  @inlinable
+  @inlinable @inline(__always)
   internal var nextTranscoded: String.Index {
-    @inline(__always) get {
-      return String.Index(
-        encodedOffset: self._encodedOffset,
-        transcodedOffset: self.transcodedOffset &+ 1)
-    }
+    return String.Index(
+      encodedOffset: self._encodedOffset,
+      transcodedOffset: self.transcodedOffset &+ 1)
   }
 
-  @inlinable
+  @inlinable @inline(__always)
   internal var priorTranscoded: String.Index {
-    @inline(__always) get {
-      return String.Index(
-        encodedOffset: self._encodedOffset,
-        transcodedOffset: self.transcodedOffset &- 1)
-    }
+    return String.Index(
+      encodedOffset: self._encodedOffset,
+      transcodedOffset: self.transcodedOffset &- 1)
   }
 
   // Get an index with an encoded offset relative to this one.