also stop using as casts

5 files changed, 53 insertions, 47 deletions

diff --git a/src/cell.rs b/src/cell.rs
index 5f09ffb..3ebf8fc 100644
--- a/src/cell.rs
+++ b/src/cell.rs
@@ -28,7 +28,7 @@ impl PartialEq<Self> for Cell {
 impl Cell {
     #[inline]
     fn len(&self) -> usize {
-        (self.len & 0x0f) as usize
+        usize::from(self.len & 0x0f)
     }
 
     pub(crate) fn set(&mut self, c: char, a: crate::attrs::Attrs) {
diff --git a/src/grid.rs b/src/grid.rs
index 21fb03c..f8aad21 100644
--- a/src/grid.rs
+++ b/src/grid.rs
@@ -38,7 +38,7 @@ impl Grid {
                 std::iter::repeat_with(|| {
                     crate::row::Row::new(self.size.cols)
                 })
-                .take(self.size.rows as usize),
+                .take(usize::from(self.size.rows)),
             );
         }
     }
@@ -78,7 +78,7 @@ impl Grid {
         for row in &mut self.rows {
             row.resize(size.cols, crate::cell::Cell::default());
         }
-        self.rows.resize(size.rows as usize, self.new_row());
+        self.rows.resize(usize::from(size.rows), self.new_row());
 
         if self.scroll_bottom >= size.rows {
             self.scroll_bottom = size.rows - 1;
@@ -136,18 +136,18 @@ impl Grid {
     }
 
     pub fn visible_row(&self, row: u16) -> Option<&crate::row::Row> {
-        self.visible_rows().nth(row as usize)
+        self.visible_rows().nth(usize::from(row))
     }
 
     pub fn drawing_row(&self, row: u16) -> Option<&crate::row::Row> {
-        self.drawing_rows().nth(row as usize)
+        self.drawing_rows().nth(usize::from(row))
     }
 
     pub fn drawing_row_mut(
         &mut self,
         row: u16,
     ) -> Option<&mut crate::row::Row> {
-        self.drawing_rows_mut().nth(row as usize)
+        self.drawing_rows_mut().nth(usize::from(row))
     }
 
     pub fn current_row_mut(&mut self) -> &mut crate::row::Row {
@@ -385,7 +385,7 @@ impl Grid {
                             );
                         }
                         contents.extend(
-                            "\n".repeat((self.pos.row - i) as usize)
+                            "\n".repeat(usize::from(self.pos.row - i))
                                 .as_bytes(),
                         );
                         found = true;
@@ -445,7 +445,7 @@ impl Grid {
 
     pub fn erase_all_forward(&mut self, attrs: crate::attrs::Attrs) {
         let pos = self.pos;
-        for row in self.drawing_rows_mut().skip(pos.row as usize + 1) {
+        for row in self.drawing_rows_mut().skip(usize::from(pos.row) + 1) {
             row.clear(attrs);
         }
 
@@ -454,7 +454,7 @@ impl Grid {
 
     pub fn erase_all_backward(&mut self, attrs: crate::attrs::Attrs) {
         let pos = self.pos;
-        for row in self.drawing_rows_mut().take(pos.row as usize) {
+        for row in self.drawing_rows_mut().take(usize::from(pos.row)) {
             row.clear(attrs);
         }
 
@@ -528,10 +528,10 @@ impl Grid {
 
     pub fn insert_lines(&mut self, count: u16) {
         for _ in 0..count {
-            self.rows.remove(self.scroll_bottom as usize);
-            self.rows.insert(self.pos.row as usize, self.new_row());
+            self.rows.remove(usize::from(self.scroll_bottom));
+            self.rows.insert(usize::from(self.pos.row), self.new_row());
             self.rows
-                .get_mut(self.scroll_bottom as usize)
+                .get_mut(usize::from(self.scroll_bottom))
                 // self.scroll_bottom is maintained to always be a valid row
                 .unwrap_or_else(|| unreachable!())
                 .wrap(false);
@@ -541,16 +541,16 @@ impl Grid {
     pub fn delete_lines(&mut self, count: u16) {
         for _ in 0..(count.min(self.size.rows - self.pos.row)) {
             self.rows
-                .insert(self.scroll_bottom as usize + 1, self.new_row());
-            self.rows.remove(self.pos.row as usize);
+                .insert(usize::from(self.scroll_bottom) + 1, self.new_row());
+            self.rows.remove(usize::from(self.pos.row));
         }
     }
 
     pub fn scroll_up(&mut self, count: u16) {
         for _ in 0..(count.min(self.size.rows - self.scroll_top)) {
             self.rows
-                .insert(self.scroll_bottom as usize + 1, self.new_row());
-            let removed = self.rows.remove(self.scroll_top as usize);
+                .insert(usize::from(self.scroll_bottom) + 1, self.new_row());
+            let removed = self.rows.remove(usize::from(self.scroll_top));
             if self.scrollback_len > 0 && !self.scroll_region_active() {
                 self.scrollback.push_back(removed);
                 while self.scrollback.len() > self.scrollback_len {
@@ -566,10 +566,11 @@ impl Grid {
 
     pub fn scroll_down(&mut self, count: u16) {
         for _ in 0..count {
-            self.rows.remove(self.scroll_bottom as usize);
-            self.rows.insert(self.scroll_top as usize, self.new_row());
+            self.rows.remove(usize::from(self.scroll_bottom));
             self.rows
-                .get_mut(self.scroll_bottom as usize)
+                .insert(usize::from(self.scroll_top), self.new_row());
+            self.rows
+                .get_mut(usize::from(self.scroll_bottom))
                 // self.scroll_bottom is maintained to always be a valid row
                 .unwrap_or_else(|| unreachable!())
                 .wrap(false);
diff --git a/src/lib.rs b/src/lib.rs
index 0567140..61bdb56 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -39,6 +39,7 @@
 #![warn(clippy::unwrap_used)]
 #![warn(clippy::expect_used)]
 #![warn(clippy::indexing_slicing)]
+#![warn(clippy::as_conversions)]
 #![allow(clippy::cognitive_complexity)]
 #![allow(clippy::missing_const_for_fn)]
 #![allow(clippy::missing_panics_doc)]
diff --git a/src/row.rs b/src/row.rs
index 64b981b..1875286 100644
--- a/src/row.rs
+++ b/src/row.rs
@@ -9,7 +9,7 @@ pub struct Row {
 impl Row {
     pub fn new(cols: u16) -> Self {
         Self {
-            cells: vec![crate::cell::Cell::default(); cols as usize],
+            cells: vec![crate::cell::Cell::default(); usize::from(cols)],
             wrapped: false,
         }
     }
@@ -34,44 +34,44 @@ impl Row {
     }
 
     pub fn get(&self, col: u16) -> Option<&crate::cell::Cell> {
-        self.cells.get(col as usize)
+        self.cells.get(usize::from(col))
     }
 
     pub fn get_mut(&mut self, col: u16) -> Option<&mut crate::cell::Cell> {
-        self.cells.get_mut(col as usize)
+        self.cells.get_mut(usize::from(col))
     }
 
     pub fn insert(&mut self, i: u16, cell: crate::cell::Cell) {
-        self.cells.insert(i as usize, cell);
+        self.cells.insert(usize::from(i), cell);
         self.wrapped = false;
     }
 
     pub fn remove(&mut self, i: u16) {
         self.clear_wide(i);
-        self.cells.remove(i as usize);
+        self.cells.remove(usize::from(i));
         self.wrapped = false;
     }
 
     pub fn erase(&mut self, i: u16, attrs: crate::attrs::Attrs) {
-        let wide = self.cells.get_mut(i as usize).unwrap().is_wide();
+        let wide = self.cells.get_mut(usize::from(i)).unwrap().is_wide();
         self.clear_wide(i);
-        self.cells.get_mut(i as usize).unwrap().clear(attrs);
+        self.cells.get_mut(usize::from(i)).unwrap().clear(attrs);
         if i == self.cols() - if wide { 2 } else { 1 } {
             self.wrapped = false;
         }
     }
 
     pub fn truncate(&mut self, len: u16) {
-        self.cells.truncate(len as usize);
+        self.cells.truncate(usize::from(len));
         self.wrapped = false;
-        let last_cell = self.cells.get_mut(len as usize - 1).unwrap();
+        let last_cell = self.cells.get_mut(usize::from(len) - 1).unwrap();
         if last_cell.is_wide() {
             last_cell.clear(*last_cell.attrs());
         }
     }
 
     pub fn resize(&mut self, len: u16, cell: crate::cell::Cell) {
-        self.cells.resize(len as usize, cell);
+        self.cells.resize(usize::from(len), cell);
         self.wrapped = false;
     }
 
@@ -108,8 +108,8 @@ impl Row {
         for (col, cell) in self
             .cells()
             .enumerate()
-            .skip(start as usize)
-            .take(width as usize)
+            .skip(usize::from(start))
+            .take(usize::from(width))
         {
             if prev_was_wide {
                 prev_was_wide = false;
@@ -176,8 +176,8 @@ impl Row {
         for (col, cell) in self
             .cells()
             .enumerate()
-            .skip(start as usize)
-            .take(width as usize)
+            .skip(usize::from(start))
+            .take(usize::from(width))
         {
             if prev_was_wide {
                 prev_was_wide = false;
@@ -198,7 +198,8 @@ impl Row {
                     {
                         if new_pos.col > 0 {
                             contents.extend(
-                                " ".repeat(new_pos.col as usize).as_bytes(),
+                                " ".repeat(usize::from(new_pos.col))
+                                    .as_bytes(),
                             );
                         } else {
                             contents.extend(b" ");
@@ -257,8 +258,9 @@ impl Row {
                 && prev_pos.col >= self.cols()
             {
                 if new_pos.col > 0 {
-                    contents
-                        .extend(" ".repeat(new_pos.col as usize).as_bytes());
+                    contents.extend(
+                        " ".repeat(usize::from(new_pos.col)).as_bytes(),
+                    );
                 } else {
                     contents.extend(b" ");
                     crate::term::Backspace::default().write_buf(contents);
@@ -333,8 +335,8 @@ impl Row {
             .cells()
             .zip(prev.cells())
             .enumerate()
-            .skip(start as usize)
-            .take(width as usize)
+            .skip(usize::from(start))
+            .take(usize::from(width))
         {
             if prev_was_wide {
                 prev_was_wide = false;
@@ -355,7 +357,8 @@ impl Row {
                     {
                         if new_pos.col > 0 {
                             contents.extend(
-                                " ".repeat(new_pos.col as usize).as_bytes(),
+                                " ".repeat(usize::from(new_pos.col))
+                                    .as_bytes(),
                             );
                         } else {
                             contents.extend(b" ");
@@ -413,8 +416,9 @@ impl Row {
                 && prev_pos.col >= self.cols()
             {
                 if new_pos.col > 0 {
-                    contents
-                        .extend(" ".repeat(new_pos.col as usize).as_bytes());
+                    contents.extend(
+                        " ".repeat(usize::from(new_pos.col)).as_bytes(),
+                    );
                 } else {
                     contents.extend(b" ");
                     crate::term::Backspace::default().write_buf(contents);
diff --git a/src/screen.rs b/src/screen.rs
index 95951d9..d083d4e 100644
--- a/src/screen.rs
+++ b/src/screen.rs
@@ -194,10 +194,10 @@ impl Screen {
                     .grid()
                     .visible_rows()
                     .enumerate()
-                    .skip(start_row as usize)
-                    .take(end_row as usize - start_row as usize + 1)
+                    .skip(usize::from(start_row))
+                    .take(usize::from(end_row) - usize::from(start_row) + 1)
                 {
-                    if i == start_row as usize {
+                    if i == usize::from(start_row) {
                         row.write_contents(
                             &mut contents,
                             start_col,
@@ -207,7 +207,7 @@ impl Screen {
                         if !row.wrapped() {
                             contents.push('\n');
                         }
-                    } else if i == end_row as usize {
+                    } else if i == usize::from(end_row) {
                         row.write_contents(&mut contents, 0, end_col, false);
                     } else {
                         row.write_contents(&mut contents, 0, cols, false);
@@ -221,7 +221,7 @@ impl Screen {
             std::cmp::Ordering::Equal => {
                 if start_col < end_col {
                     self.rows(start_col, end_col - start_col)
-                        .nth(start_row as usize)
+                        .nth(usize::from(start_row))
                         .unwrap_or_else(String::new)
                 } else {
                     String::new()
@@ -811,7 +811,7 @@ impl Screen {
         let attrs = self.attrs;
 
         let width = c.width();
-        if width.is_none() && (c as u32) < 256 {
+        if width.is_none() && (u32::from(c)) < 256 {
             // don't even try to draw control characters
             return;
         }