     _internalInvariant(smol._guts.isSmall)
     return smol._guts.asSmall
   }
-  
+
   private func _convertedToSmall() -> _SmallString {
     _internalInvariant(utf8Count <= _SmallString.capacity)
     if _fastPath(isSmall) {

    defer { self._invariantCheck() }

    let otherCount = slicedOther.utf8Count
    
    let totalCount = utf8Count + otherCount
    
    /*
     Goal: determine if we need to allocate new native capacity
     Possible scenarios in which we need to allocate:
     • Not uniquely owned and native: we can't use the capacity to grow into,
        have to become unique + native by allocating
     • Not enough capacity: have to allocate to grow
     
     Special case: a non-smol String that can fit in a smol String but doesn't
        meet the above criteria shouldn't throw away its buffer just to be smol.
        The reasoning here is that it may be bridged or have reserveCapacity'd
        in preparation for appending more later, in which case we would end up
        have to allocate anyway to convert back from smol.
     
        If we would have to re-allocate anyway then that's not a problem and we
        should just be smol.
     
        e.g. consider
        var str = "" // smol
        str.reserveCapacity(100) // large native unique

    } else {
      sufficientCapacity = false
    }

    if self.isUniqueNative && sufficientCapacity {
      return
    }

    // If we have to resize anyway, and we fit in smol, we should have made one
    _internalInvariant(totalCount > _SmallString.capacity)

