slicelen -> slice_len

Author: youknowone

stdlib/src/mmap.rs

@@ -934,11 +934,11 @@ mod mmap {
             slice: &SaturatedSlice,
             vm: &VirtualMachine,
         ) -> PyResult<PyObjectRef> {
-            let (range, step, slicelen) = slice.adjust_indices(self.len());
+            let (range, step, slice_len) = slice.adjust_indices(self.len());
 
             let mmap = self.check_valid(vm)?;
 
-            if slicelen == 0 {
+            if slice_len == 0 {
                 return Ok(PyBytes::from(vec![]).into_ref(vm).into());
             } else if step == 1 {
                 let bytes = match mmap.deref().as_ref().unwrap() {
@@ -948,7 +948,7 @@ mod mmap {
                 return Ok(PyBytes::from(bytes.to_vec()).into_ref(vm).into());
             }
 
-            let mut result_buf = Vec::with_capacity(slicelen);
+            let mut result_buf = Vec::with_capacity(slice_len);
             if step.is_negative() {
                 for i in range.rev().step_by(step.unsigned_abs()) {
                     let b = match mmap.deref().as_ref().unwrap() {
@@ -1017,15 +1017,15 @@ mod mmap {
             value: PyObjectRef,
             vm: &VirtualMachine,
         ) -> PyResult<()> {
-            let (range, step, slicelen) = slice.adjust_indices(zelf.len());
+            let (range, step, slice_len) = slice.adjust_indices(zelf.len());
 
             let bytes = bytes_from_object(vm, &value)?;
 
-            if bytes.len() != slicelen {
+            if bytes.len() != slice_len {
                 return Err(vm.new_index_error("mmap slice assignment is wrong size".to_owned()));
             }
 
-            if slicelen == 0 {
+            if slice_len == 0 {
                 // do nothing
                 Ok(())
             } else if step == 1 {

vm/src/builtins/memory.rs

@@ -479,7 +479,7 @@ impl PyMemoryView {
     fn init_slice(&mut self, slice: &PySlice, dim: usize, vm: &VirtualMachine) -> PyResult<()> {
         let (shape, stride, _) = self.desc.dim_desc[dim];
         let slice = slice.to_saturated(vm)?;
-        let (range, step, slicelen) = slice.adjust_indices(shape);
+        let (range, step, slice_len) = slice.adjust_indices(shape);
 
         let mut is_adjusted_suboffset = false;
         for (_, _, suboffset) in self.desc.dim_desc.iter_mut().rev() {
@@ -498,7 +498,7 @@ impl PyMemoryView {
                     range.start
                 };
         }
-        self.desc.dim_desc[dim].0 = slicelen;
+        self.desc.dim_desc[dim].0 = slice_len;
         self.desc.dim_desc[dim].1 *= step;
 
         Ok(())

vm/src/sliceable.rs

@@ -44,16 +44,16 @@ where
         slice: SaturatedSlice,
         items: &[Self::Item],
     ) -> PyResult<()> {
-        let (range, step, slicelen) = slice.adjust_indices(self.as_ref().len());
-        if slicelen != items.len() {
+        let (range, step, slice_len) = slice.adjust_indices(self.as_ref().len());
+        if slice_len != items.len() {
             Err(vm
                 .new_buffer_error("Existing exports of data: object cannot be re-sized".to_owned()))
         } else if step == 1 {
             self.do_set_range(range, items);
             Ok(())
         } else {
             self.do_set_indexes(
-                SaturatedSliceIter::from_adjust_indices(range, step, slicelen),
+                SaturatedSliceIter::from_adjust_indices(range, step, slice_len),
                 items,
             );
             Ok(())
@@ -66,21 +66,21 @@ where
         slice: SaturatedSlice,
         items: &[Self::Item],
     ) -> PyResult<()> {
-        let (range, step, slicelen) = slice.adjust_indices(self.as_ref().len());
+        let (range, step, slice_len) = slice.adjust_indices(self.as_ref().len());
         if step == 1 {
             self.do_set_range(range, items);
             Ok(())
-        } else if slicelen == items.len() {
+        } else if slice_len == items.len() {
             self.do_set_indexes(
-                SaturatedSliceIter::from_adjust_indices(range, step, slicelen),
+                SaturatedSliceIter::from_adjust_indices(range, step, slice_len),
                 items,
             );
             Ok(())
         } else {
             Err(vm.new_value_error(format!(
                 "attempt to assign sequence of size {} to extended slice of size {}",
                 items.len(),
-                slicelen
+                slice_len
             )))
         }
     }
@@ -95,16 +95,16 @@ where
     }
 
     fn del_item_by_slice(&mut self, _vm: &VirtualMachine, slice: SaturatedSlice) -> PyResult<()> {
-        let (range, step, slicelen) = slice.adjust_indices(self.as_ref().len());
-        if slicelen == 0 {
+        let (range, step, slice_len) = slice.adjust_indices(self.as_ref().len());
+        if slice_len == 0 {
             Ok(())
         } else if step == 1 {
             self.do_set_range(range, &[]);
             Ok(())
         } else {
             self.do_delete_indexes(
                 range.clone(),
-                SaturatedSliceIter::from_adjust_indices(range, step, slicelen).positive_order(),
+                SaturatedSliceIter::from_adjust_indices(range, step, slice_len).positive_order(),
             );
             Ok(())
         }
@@ -187,8 +187,8 @@ pub trait SliceableSequenceOp {
         _vm: &VirtualMachine,
         slice: SaturatedSlice,
     ) -> PyResult<Self::Sliced> {
-        let (range, step, slicelen) = slice.adjust_indices(self.len());
-        let sliced = if slicelen == 0 {
+        let (range, step, slice_len) = slice.adjust_indices(self.len());
+        let sliced = if slice_len == 0 {
             Self::empty()
         } else if step == 1 {
             if step.is_negative() {
@@ -395,13 +395,13 @@ impl SaturatedSlice {
             saturate_index(self.start, len)..saturate_index(self.stop, len)
         };
 
-        let (range, slicelen) = if range.start >= range.end {
+        let (range, slice_len) = if range.start >= range.end {
             (range.start..range.start, 0)
         } else {
-            let slicelen = (range.end - range.start - 1) / self.step.unsigned_abs() + 1;
-            (range, slicelen)
+            let slice_len = (range.end - range.start - 1) / self.step.unsigned_abs() + 1;
+            (range, slice_len)
         };
-        (range, self.step, slicelen)
+        (range, self.step, slice_len)
     }
 
     pub fn iter(&self, len: usize) -> SaturatedSliceIter {