[stdlib] Fix String.split() and start fixing String.__len__()

docs/changelog.md

@@ -139,6 +139,11 @@ what we publish.
 
 - Added `StringSlice(..)` initializer from a `StringLiteral`.
 
+- Added a `byte_length()` method to `String`, `StringSlice`, and `StringLiteral`
+and deprecated their private `_byte_length()` methods. Added a warning to
+`String.__len__` method that it will return length in Unicode codepoints in the
+future and `StringSlice.__len__` now does return the Unicode codepoints length.
+
 - Added new `StaticString` type alias. This can be used in place of
   `StringLiteral` for runtime string arguments.
 

stdlib/src/base64/base64.mojo

@@ -72,7 +72,7 @@ fn b64encode(str: String) -> String:
     alias lookup = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
     var b64chars = lookup.unsafe_ptr()
 
-    var length = len(str)
+    var length = str.byte_length()
     var out = String._buffer_type(capacity=length + 1)
 
     @parameter
@@ -121,7 +121,7 @@ fn b64decode(str: String) -> String:
     Returns:
       The decoded string.
     """
-    var n = len(str)
+    var n = str.byte_length()
     debug_assert(n % 4 == 0, "Input length must be divisible by 4")
 
     var p = String._buffer_type(capacity=n + 1)
@@ -170,7 +170,7 @@ fn b16encode(str: String) -> String:
     alias lookup = "0123456789ABCDEF"
     var b16chars = lookup.unsafe_ptr()
 
-    var length = len(str)
+    var length = str.byte_length()
     var out = List[UInt8](capacity=length * 2 + 1)
 
     @parameter
@@ -221,7 +221,7 @@ fn b16decode(str: String) -> String:
 
         return -1
 
-    var n = len(str)
+    var n = str.byte_length()
     debug_assert(n % 2 == 0, "Input length must be divisible by 2")
 
     var p = List[UInt8](capacity=n // 2 + 1)

stdlib/src/builtin/error.mojo

@@ -80,7 +80,7 @@ struct Error(
         Returns:
             The constructed Error object.
         """
-        var length = len(src)
+        var length = src.byte_length()
         var dest = UnsafePointer[UInt8].alloc(length + 1)
         memcpy(
             dest=dest,

stdlib/src/builtin/file.mojo

@@ -239,7 +239,7 @@ struct FileHandle:
         var bytes = file.read(ptr, 8)
         print("bytes read", bytes)
 
-        var first_element = ptr.load(0)
+        var first_element = ptr[0]
         print(first_element)
 
         # Skip 2 elements
@@ -374,15 +374,15 @@ struct FileHandle:
         ```mojo
         import os
         var f = open("/tmp/example.txt", "r")
-        f.seek(os.SEEK_CUR, 32)
+        _ = f.seek(32, os.SEEK_CUR)
         ```
 
         Start from 32 bytes from the end of the file:
 
         ```mojo
         import os
         var f = open("/tmp/example.txt", "r")
-        f.seek(os.SEEK_END, -32)
+        _ = f.seek(-32, os.SEEK_END)
         ```
         .
         """
@@ -409,7 +409,7 @@ struct FileHandle:
         Args:
           data: The data to write to the file.
         """
-        self._write(data.unsafe_ptr(), len(data))
+        self._write(data.unsafe_ptr(), data.byte_length())
 
     fn write(self, data: Span[UInt8, _]) raises:
         """Write a borrowed sequence of data to the file.

stdlib/src/builtin/io.mojo

@@ -320,7 +320,7 @@ fn _put(x: DType, file: FileDescriptor = stdout):
 @no_inline
 fn _put(x: StringSlice, file: FileDescriptor = stdout):
     # Avoid printing "(null)" for an empty/default constructed `String`
-    var str_len = x._byte_length()
+    var str_len = x.byte_length()
 
     if not str_len:
         return
@@ -341,7 +341,7 @@ fn _put(x: StringSlice, file: FileDescriptor = stdout):
 
         # The string can be printed, so that's fine.
         if str_len < MAX_STR_LEN:
-            _printf["%.*s"](x._byte_length(), x.unsafe_ptr(), file=file)
+            _printf["%.*s"](x.byte_length(), x.unsafe_ptr(), file=file)
             return
 
         # The string is large, then we need to chunk it.