lint: fix clippy::pedantic (16-20 entries)

Author: magistau

Cargo.toml

@@ -17,9 +17,7 @@ print_stdout = "warn"
 print_stderr = "allow"
 dbg_macro = "warn"
 pedantic = {level = "warn", priority = -1}
-manual_assert = "allow"  # 16
-inline_always = "allow"  # 18
-from_iter_instead_of_collect = "allow"  # 20
+inline_always = "allow"  # TODO: benchmark inlines
 default_trait_access = "allow"  # 23
 format_push_string = "allow"  # 27
 missing_panics_doc = "allow"  # 37

site/src/main.rs

@@ -665,19 +665,21 @@ fn site() {
             (Err(_), true) => {}
             (Ok(mut comp), should_fail) => {
                 if let Some(diag) = comp.take_diagnostics().into_iter().next() {
-                    if !should_fail {
-                        panic!(
-                            "Test failed in {}\n{}\n{}",
-                            path.display(),
-                            code,
-                            diag.report()
-                        );
-                    }
+                    assert!(
+                        should_fail,
+                        "Test failed in {}\n{}\n{}",
+                        path.display(),
+                        code,
+                        diag.report()
+                    );
                     continue;
                 }
-                if should_fail {
-                    panic!("Test should have failed in {}\n{}", path.display(), code);
-                }
+                assert!(
+                    !should_fail,
+                    "Test should have failed in {}\n{}",
+                    path.display(),
+                    code
+                )
             }
         }
     }

site/src/markdown.rs

@@ -476,11 +476,9 @@ fn text_code_blocks() {
                 Err(e) => Some(e.report()),
             };
             if let Some(report) = failure_report {
-                if !should_fail {
-                    panic!("\nBlock failed:\n{block}\n{report}")
-                }
-            } else if should_fail {
-                panic!("\nBlock should have failed:\n{block}")
+                assert!(should_fail, "\nBlock failed:\n{block}\n{report}");
+            } else {
+                assert!(!should_fail, "\nBlock should have failed:\n{block}");
             }
         }
     }

site/src/primitive.rs

@@ -428,17 +428,27 @@ fn prim_docs() {
                 match Uiua::with_backend(WebBackend::default()).run_str(ex.input()) {
                     Ok(mut comp) => {
                         if let Some(diag) = comp.take_diagnostics().into_iter().next() {
-                            if !ex.should_error() {
-                                panic!("\nExample failed:\n{}\n{}", ex.input(), diag.report());
-                            }
-                        } else if ex.should_error() {
-                            panic!("Example should have failed: {}", ex.input());
+                            assert!(
+                                ex.should_error(),
+                                "\nExample failed:\n{}\n{}",
+                                ex.input(),
+                                diag.report()
+                            );
+                        } else {
+                            assert!(
+                                !ex.should_error(),
+                                "Example should have failed: {}",
+                                ex.input()
+                            );
                         }
                     }
                     Err(e) => {
-                        if !ex.should_error() {
-                            panic!("\nExample failed:\n{}\n{}", ex.input(), e.report());
-                        }
+                        assert!(
+                            ex.should_error(),
+                            "\nExample failed:\n{}\n{}",
+                            ex.input(),
+                            e.report()
+                        );
                     }
                 }
             }

src/algorithm/dyadic/structure.rs

@@ -1615,7 +1615,7 @@ impl<T: ArrayValue> Array<T> {
             .map(|&i| normalize_index(i, indices.len()))
             .collect();
         let outer_rank = indices_shape.last().copied().unwrap_or(1);
-        let mut outer_shape = Shape::from_iter(repeat_n(0, outer_rank));
+        let mut outer_shape = repeat_n(0, outer_rank).collect::<Shape>();
         if !normalized_indices.is_empty() {
             for index in normalized_indices.chunks_exact(index_size) {
                 for (d, &i) in outer_shape.iter_mut().zip(index) {

src/algorithm/map.rs

@@ -818,7 +818,7 @@ fn coerce_values(
     }
     if let Value::Box(b_arr) = &b {
         if b_arr.rank() == 0 && !matches!(a, Value::Box(_)) {
-            *a = Array::from_iter(a.rows().map(Boxed)).into();
+            *a = a.rows().map(Boxed).collect::<Array<_>>().into();
             return Ok(b);
         }
     }

src/algorithm/monadic/mod.rs

@@ -516,7 +516,7 @@ impl Value {
         if ishape.is_empty() {
             return Ok(Array::<f64>::new(0, CowSlice::new()).into());
         }
-        let mut shape = Shape::from_iter(ishape.iter().map(|d| d.unsigned_abs()));
+        let mut shape = ishape.iter().map(|d| d.unsigned_abs()).collect::<Shape>();
         shape.push(shape.len());
         let data = range(&ishape, start, env)?;
         let mut value: Value = match data {
@@ -534,9 +534,9 @@ impl Value {
             env,
             "Shape should be a single integer or a list of integers",
         )?;
-        let shape = Shape::from_iter(ishape.iter().map(|n| n.unsigned_abs()));
+        let shape = ishape.iter().map(|n| n.unsigned_abs()).collect::<Shape>();
         let elems: usize = validate_size::<f64>(shape.iter().copied(), env)?;
-        let data = EcoVec::from_iter((0..elems).map(|i| i as f64));
+        let data = (0..elems).map(|i| i as f64).collect::<EcoVec<_>>();
         let mut arr = Array::new(shape, data);
         let first_max = ishape.first().copied().unwrap_or(0);
         for (i, s) in ishape.into_iter().enumerate() {
@@ -1077,7 +1077,7 @@ impl<T: ArrayValue> Array<T> {
             return;
         }
         let subshape = Shape::from(&self.shape[depth..]);
-        let newshape = Shape::from_iter(subshape.iter().rev().copied());
+        let newshape = subshape.iter().rev().copied().collect::<Shape>();
         let chunk_size = subshape.elements();
         let data_slice = self.data.as_mut_slice();
         let mut temp = data_slice[..chunk_size].to_vec();
@@ -1787,7 +1787,10 @@ impl Value {
     /// Convert a string value to a list of UTF-16 code units
     pub fn utf16(&self, env: &Uiua) -> UiuaResult<Self> {
         let s = self.as_string(env, "Argument to utf₁₆ must be a string")?;
-        Ok(Array::<f64>::from_iter(s.encode_utf16().map(|u| u as f64)).into())
+        Ok(s.encode_utf16()
+            .map(|u| u as f64)
+            .collect::<Array<f64>>()
+            .into())
     }
     /// Convert a list of UTF-8 bytes to a string value
     pub fn unutf8(&self, env: &Uiua) -> UiuaResult<Self> {

src/algorithm/stencil.rs

@@ -86,11 +86,11 @@ where
         let total_len = *s + 2 * d.fill * d.stride;
         shape_prefix.push((total_len + d.stride).saturating_sub(d.size) / d.stride);
     }
-    let window_shape = Shape::from_iter(
-        dims.iter()
-            .map(|d| d.size)
-            .chain(arr.shape.iter().skip(dims.len()).copied()),
-    );
+    let window_shape = dims
+        .iter()
+        .map(|d| d.size)
+        .chain(arr.shape.iter().skip(dims.len()).copied())
+        .collect::<Shape>();
     if shape_prefix.contains(&0) {
         let mut shape = shape_prefix;
         shape.extend(window_shape);

src/array.rs

@@ -499,9 +499,10 @@ impl<T: Clone> Array<T> {
             return row;
         }
         let row_count = self.row_count();
-        if row >= row_count {
-            panic!("row index out of bounds: {row} >= {row_count}");
-        }
+        assert!(
+            row < row_count,
+            "row index out of bounds: {row} >= {row_count}"
+        );
         let row_len = self.row_len();
         let start = row * row_len;
         let end = start + row_len;
@@ -604,9 +605,10 @@ impl<T: ArrayValue> Array<T> {
             return row;
         }
         let row_count: usize = self.shape[..=depth].iter().product();
-        if row >= row_count {
-            panic!("row index out of bounds: {row} >= {row_count}");
-        }
+        assert!(
+            row < row_count,
+            "row index out of bounds: {row} >= {row_count}"
+        );
         let row_len: usize = self.shape[depth + 1..].iter().product();
         let start = row * row_len;
         let end = start + row_len;

src/compile/data.rs

@@ -346,7 +346,13 @@ impl Compiler {
         self.compile_bind_const(
             name,
             local,
-            Some(Array::from_iter(fields.iter().map(|f| f.name.as_str())).into()),
+            Some(
+                fields
+                    .iter()
+                    .map(|f| f.name.as_str())
+                    .collect::<Array<_>>()
+                    .into(),
+            ),
             span,
             BindingMeta {
                 comment: Some(DocComment::from(comment.as_str())),