[stdlib] Inline unnecessary helper functions for List

stdlib/src/collections/list.mojo

@@ -470,22 +470,23 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
     # Methods
     # ===-------------------------------------------------------------------===#
 
-    fn bytecount(self) -> Int:
-        """Gets the bytecount of the List.
+    fn byte_length(self) -> Int:
+        """Gets the byte length of the List.
 
         Returns:
-            The bytecount of the List.
+            The byte length of the List.
         """
         return len(self) * sizeof[T]()
 
     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()
@@ -723,22 +724,23 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
         Raises:
             ValueError: If the value is not found in the list.
         """
-        var start_normalized = start
 
+        var s_len = len(self)
+        var start_normalized = start
         var stop_normalized: Int
         if stop is None:
             # Default end
-            stop_normalized = len(self)
+            stop_normalized = s_len
         else:
             stop_normalized = stop.value()
 
         if start_normalized < 0:
-            start_normalized += len(self)
+            start_normalized += s_len
         if stop_normalized < 0:
-            stop_normalized += len(self)
+            stop_normalized += s_len
 
-        start_normalized = _clip(start_normalized, 0, len(self))
-        stop_normalized = _clip(stop_normalized, 0, len(self))
+        start_normalized = max(0, min(start_normalized, s_len))
+        stop_normalized = max(0, min(stop_normalized, s_len))
 
         for i in range(start_normalized, stop_normalized):
             if self[i] == value:
@@ -932,22 +934,3 @@ struct List[T: CollectionElement, hint_trivial_type: Bool = False](
             The UnsafePointer to the underlying memory.
         """
         return self.data
-
-
-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/memory/memory.mojo

@@ -251,11 +251,10 @@ fn memcpy[
         src: The source pointer.
         count: The number of elements to copy.
     """
-    var n = count * sizeof[dest.type]()
     _memcpy_impl(
         dest.bitcast[Byte, origin=MutableAnyOrigin](),
         src.bitcast[Byte, origin=MutableAnyOrigin](),
-        n,
+        count * sizeof[T](),
     )
 
 

stdlib/test/collections/test_list.mojo

@@ -39,7 +39,7 @@ def test_list():
         list.append(i)
 
     assert_equal(5, len(list))
-    assert_equal(5 * sizeof[Int](), list.bytecount())
+    assert_equal(5 * sizeof[Int](), list.byte_length())
     assert_equal(0, list[0])
     assert_equal(1, list[1])
     assert_equal(2, list[2])

stdlib/test/python/my_module.py

@@ -25,7 +25,8 @@ def __init__(self, bar):
 
 class AbstractPerson(ABC):
     @abstractmethod
-    def method(self): ...
+    def method(self):
+        ...
 
 
 def my_function(name):