[stdlib] Rename List.size to List._len and refactor usage of the field to use the public API

docs/changelog.md

@@ -118,6 +118,7 @@ what we publish.
 - `StringRef` is being deprecated. Use `StringSlice` instead.
   - Changed `sys.argv()` to return list of `StringSlice`.
   - removed `StringRef.startswith()` and `StringRef.endswith()`
+- Direct access to `List.size` has been removed. Use the public API instead.
 
 ### 🛠️ Fixed
 

pixi.toml

@@ -12,4 +12,4 @@ benchmarks = { cmd = ["./stdlib/scripts/run-benchmarks.sh"], env = { MODULAR_MOJ
 [dependencies]
 python = ">=3.9,<3.13"
 lit = "*"
-max = "*"
+max = "*"

stdlib/src/builtin/file.mojo

@@ -140,7 +140,7 @@ struct FileHandle:
         """Reads data from a file and sets the file handle seek position. If
         size is left as the default of -1, it will read to the end of the file.
         Setting size to a number larger than what's in the file will set
-        String.size to the total number of bytes, and read all the data.
+        the String length to the total number of bytes, and read all the data.
 
         Args:
             size: Requested number of bytes to read (Default: -1 = EOF).
@@ -284,7 +284,7 @@ struct FileHandle:
         """Reads data from a file and sets the file handle seek position. If
         size is left as default of -1, it will read to the end of the file.
         Setting size to a number larger than what's in the file will be handled
-        and set the List.size to the total number of bytes in the file.
+        and set the List length to the total number of bytes in the file.
 
         Args:
             size: Requested number of bytes to read (Default: -1 = EOF).

stdlib/src/builtin/string_literal.mojo

@@ -381,17 +381,11 @@ struct StringLiteral(
         # inline the string slice constructor to work around an elaborator
         # memory leak.
         # return self.as_string_slice()
-        var string = String()
         var length = self.byte_length()
-        var buffer = String._buffer_type()
-        var new_capacity = length + 1
-        buffer._realloc(new_capacity)
-        buffer.size = new_capacity
-        var data: UnsafePointer[UInt8] = self.unsafe_ptr()
-        memcpy(buffer.data, data, length)
-        (buffer.data + length).init_pointee_move(0)
-        string._buffer = buffer^
-        return string
+        var buffer = String._buffer_type(capacity=length + 1)
+        buffer.extend(self.as_bytes())
+        buffer.append(0)
+        return String(buffer^)
 
     @no_inline
     fn __repr__(self) -> String:

stdlib/src/collections/list.mojo

@@ -99,7 +99,7 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
     # Fields
     var data: UnsafePointer[T]
     """The underlying storage for the list."""
-    var size: Int
+    var _len: Int
     """The number of elements in the list."""
     var capacity: Int
     """The amount of elements that can fit in the list without resizing it."""
@@ -111,7 +111,7 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
     fn __init__(out self):
         """Constructs an empty list."""
         self.data = UnsafePointer[T]()
-        self.size = 0
+        self._len = 0
         self.capacity = 0
 
     fn copy(self) -> Self:
@@ -132,7 +132,7 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
             capacity: The requested capacity of the list.
         """
         self.data = UnsafePointer[T].alloc(capacity)
-        self.size = 0
+        self._len = 0
         self.capacity = capacity
 
     @implicit
@@ -165,7 +165,7 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
             __get_mvalue_as_litref(elements)
         )
 
-        self.size = length
+        self._len = length
 
     @implicit
     fn __init__(out self, span: Span[T]):
@@ -187,7 +187,7 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
             capacity: The capacity of the list.
         """
         self.data = ptr
-        self.size = length
+        self._len = length
         self.capacity = capacity
 
     fn __moveinit__(out self, owned existing: Self):
@@ -197,7 +197,7 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
             existing: The existing list.
         """
         self.data = existing.data
-        self.size = existing.size
+        self._len = existing._len
         self.capacity = existing.capacity
 
     fn __copyinit__(out self, existing: Self):
@@ -215,7 +215,7 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
 
         @parameter
         if not hint_trivial_type:
-            for i in range(self.size):
+            for i in range(len(self)):
                 (self.data + i).destroy_pointee()
         self.data.free()
 
@@ -372,13 +372,14 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
     # Trait implementations
     # ===-------------------------------------------------------------------===#
 
+    @always_inline("nodebug")
     fn __len__(self) -> Int:
         """Gets the number of elements in the list.
 
         Returns:
             The number of elements in the list.
         """
-        return self.size
+        return self._len
 
     fn __bool__(self) -> Bool:
         """Checks whether the list has any elements or not.
@@ -414,7 +415,9 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
         Returns:
             A string representation of the list.
         """
-        var output = String()
+        # at least 1 byte per item e.g.: [a, b, c, d] = 4 + 2 * 3 + [] + null
+        var l = len(self)
+        var output = String(capacity=l + 2 * (l - 1) * int(l > 1) + 3)
         self.write_to(output)
         return output^
 
@@ -481,11 +484,12 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
     fn _realloc(mut self, new_capacity: Int):
         var new_data = UnsafePointer[T].alloc(new_capacity)
 
-        _move_pointee_into_many_elements[hint_trivial_type](
-            dest=new_data,
-            src=self.data,
-            size=self.size,
-        )
+        @parameter
+        if hint_trivial_type:
+            memcpy(new_data, self.data, len(self))
+        else:
+            for i in range(len(self)):
+                (self.data + i).move_pointee_into(new_data + i)
 
         if self.data:
             self.data.free()
@@ -502,10 +506,10 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
             If there is no capacity left, resizes to twice the current capacity.
             Except for 0 capacity where it sets 1.
         """
-        if self.size >= self.capacity:
+        if self._len >= self.capacity:
             self._realloc(self.capacity * 2 | int(self.capacity == 0))
-        (self.data + self.size).init_pointee_move(value^)
-        self.size += 1
+        (self.data + self._len).init_pointee_move(value^)
+        self._len += 1
 
     fn insert(mut self, i: Int, owned value: T):
         """Inserts a value to the list at the given index.
@@ -515,7 +519,7 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
             i: The index for the value.
             value: The value to insert.
         """
-        debug_assert(i <= self.size, "insert index out of range")
+        debug_assert(i <= len(self), "insert index out of range")
 
         var normalized_idx = i
         if i < 0:
@@ -576,7 +580,7 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
         # visible outside this function if a `__moveinit__()` constructor were
         # to throw (not currently possible AFAIK though) part way through the
         # logic below.
-        other.size = 0
+        other._len = 0
 
         var dest_ptr = self.data + len(self)
 
@@ -593,7 +597,7 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
 
         # Update the size now that all new elements have been moved into this
         # list.
-        self.size = final_size
+        self._len = final_size
 
     fn extend[
         D: DType, //
@@ -609,9 +613,9 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
         Notes:
             If there is no capacity left, resizes to `len(self) + value.size`.
         """
-        self.reserve(self.size + value.size)
-        (self.data + self.size).store(value)
-        self.size += value.size
+        self.reserve(self._len + value.size)
+        (self.data + self._len).store(value)
+        self._len += value.size
 
     fn extend[
         D: DType, //
@@ -630,10 +634,10 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
             If there is no capacity left, resizes to `len(self) + count`.
         """
         debug_assert(count <= value.size, "count must be <= value.size")
-        self.reserve(self.size + count)
+        self.reserve(self._len + count)
         var v_ptr = UnsafePointer.address_of(value).bitcast[Scalar[D]]()
-        memcpy(self.data + self.size, v_ptr, count)
-        self.size += count
+        memcpy(self.data + self._len, v_ptr, count)
+        self._len += count
 
     fn extend[
         D: DType, //
@@ -649,9 +653,9 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
         Notes:
             If there is no capacity left, resizes to `len(self) + len(value)`.
         """
-        self.reserve(self.size + len(value))
-        memcpy(self.data + self.size, value.unsafe_ptr(), len(value))
-        self.size += len(value)
+        self.reserve(self._len + len(value))
+        memcpy(self.data + self._len, value.unsafe_ptr(), len(value))
+        self._len += len(value)
 
     fn pop(mut self, i: Int = -1) -> T:
         """Pops a value from the list at the given index.
@@ -662,17 +666,17 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
         Returns:
             The popped value.
         """
-        debug_assert(-len(self) <= i < len(self), "pop index out of range")
+        debug_assert(-self._len <= i < self._len, "pop index out of range")
 
         var normalized_idx = i
         if i < 0:
-            normalized_idx += len(self)
+            normalized_idx += self._len
 
         var ret_val = (self.data + normalized_idx).take_pointee()
-        for j in range(normalized_idx + 1, self.size):
+        for j in range(normalized_idx + 1, self._len):
             (self.data + j).move_pointee_into(self.data + j - 1)
-        self.size -= 1
-        if self.size * 4 < self.capacity:
+        self._len -= 1
+        if self._len * 4 < self.capacity:
             if self.capacity > 1:
                 self._realloc(self.capacity // 2)
         return ret_val^
@@ -701,13 +705,13 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
             new_size: The new size.
             value: The value to use to populate new elements.
         """
-        if new_size <= self.size:
+        if new_size <= self._len:
             self.resize(new_size)
         else:
             self.reserve(new_size)
-            for i in range(self.size, new_size):
+            for i in range(self._len, new_size):
                 (self.data + i).init_pointee_copy(value)
-            self.size = new_size
+            self._len = new_size
 
     fn resize(mut self, new_size: Int):
         """Resizes the list to the given new size.
@@ -718,16 +722,16 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
         Args:
             new_size: The new size.
         """
-        if self.size < new_size:
+        if len(self) < new_size:
             abort(
                 "You are calling List.resize with a new_size bigger than the"
                 " current size. If you want to make the List bigger, provide a"
                 " value to fill the new slots with. If not, make sure the new"
                 " size is smaller than the current size."
             )
-        for i in range(new_size, self.size):
+        for i in range(new_size, len(self)):
             (self.data + i).destroy_pointee()
-        self.size = new_size
+        self._len = new_size
         self.reserve(new_size)
 
     fn reverse(mut self):
@@ -809,9 +813,9 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
 
     fn clear(mut self):
         """Clears the elements in the list."""
-        for i in range(self.size):
+        for i in range(self._len):
             (self.data + i).destroy_pointee()
-        self.size = 0
+        self._len = 0
 
     fn steal_data(mut self) -> UnsafePointer[T]:
         """Take ownership of the underlying pointer from the list.
@@ -821,7 +825,7 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
         """
         var ptr = self.data
         self.data = UnsafePointer[T]()
-        self.size = 0
+        self._len = 0
         self.capacity = 0
         return ptr
 
@@ -863,11 +867,11 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
         var normalized_idx = idx
 
         debug_assert(
-            -self.size <= normalized_idx < self.size,
+            -len(self) <= normalized_idx < len(self),
             "index: ",
             normalized_idx,
-            " is out of bounds for `List` of size: ",
-            self.size,
+            " is out of bounds for `List` of length: ",
+            len(self),
         )
         if normalized_idx < 0:
             normalized_idx += len(self)
@@ -1003,18 +1007,3 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
 
 fn _clip(value: Int, start: Int, end: Int) -> Int:
     return max(start, min(value, end))
-
-
-fn _move_pointee_into_many_elements[
-    T: CollectionElement, //, hint_trivial_type: Bool
-](dest: UnsafePointer[T], src: UnsafePointer[T], size: Int):
-    @parameter
-    if hint_trivial_type:
-        memcpy(
-            dest=dest.bitcast[Int8](),
-            src=src.bitcast[Int8](),
-            count=size * sizeof[T](),
-        )
-    else:
-        for i in range(size):
-            (src + i).move_pointee_into(dest + i)

stdlib/src/collections/string/format.mojo

@@ -145,8 +145,7 @@ struct _FormatCurlyEntry(CollectionElement, CollectionElementNew):
         entries, size_estimation = Self._create_entries(fmt_src, len_pos_args)
         var fmt_len = fmt_src.byte_length()
         var buf = String._buffer_type(capacity=fmt_len + size_estimation)
-        buf.size = 1
-        buf.unsafe_set(0, 0)
+        buf.append(0)
         var res = String(buf^)
         var offset = 0
         var ptr = fmt_src.unsafe_ptr()