📎 Fix all clippy warnings, add &mut [T] macro support

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: timfennis

.cargo/config.toml

@@ -12,7 +12,7 @@ rustflags = [
     "-Wclippy::dbg_macro",
     "-Wclippy::debug_assert_with_mut_call",
     "-Wclippy::doc_markdown",
-    "-Wclippy::empty_enum",
+    "-Wclippy::empty_enums",
     "-Wclippy::enum_glob_use",
     "-Wclippy::exit",
     "-Wclippy::expl_impl_clone_on_copy",
@@ -76,7 +76,7 @@ rustflags = [
     "-Wtrivial-numeric-casts",
     "-Wunused-crate-dependencies",
     "-Wunused-qualifications",
-    "-Wclippy::as_conversions",
+    "-Aclippy::as_conversions",
     "-Wclippy::as_pointer_underscore",
     "-Wclippy::doc_include_without_cfg",
     "-Wclippy::get_unwrap",

CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Before commit
 - Run `cargo fmt`
-- Run `cargo check` and fix warnings and errors
+- Run `cargo clippy` and fix all warnings
 - Ensure all tests pass (`cargo test`)
 - Do not leave `TODO` comments in code — either fix the issue immediately or open a GitHub issue and record it in `TODO.md`
 

ndc_bin/build.rs

@@ -5,7 +5,11 @@ fn main() {
         .args(["rev-parse", "--short", "HEAD"])
         .output()
         .ok()
-        .filter(|o| o.status.success()).map_or_else(|| "unknown".to_string(), |o| String::from_utf8_lossy(&o.stdout).trim().to_string());
+        .filter(|o| o.status.success())
+        .map_or_else(
+            || "unknown".to_string(),
+            |o| String::from_utf8_lossy(&o.stdout).trim().to_string(),
+        );
 
     let dirty = Command::new("git")
         .args(["diff", "--quiet", "HEAD"])

ndc_core/src/static_type.rs

@@ -314,11 +314,10 @@ impl StaticType {
 
                 // Parameters: contravariant, so we need GLB (greatest lower bound)
                 let parameters = match (p1, p2) {
-                    (None, None) => None,
                     (Some(ps1), Some(ps2)) if ps1.len() == ps2.len() => {
                         Some(ps1.iter().zip(ps2).map(|(a, b)| a.glb(b)).collect())
                     }
-                    // Incompatible parameter lists
+                    // Incompatible or unknown parameter lists
                     _ => None,
                 };
 

ndc_lsp/src/backend.rs

@@ -258,8 +258,9 @@ fn collect_hints(expr: &ExpressionLocation, text: &str, hints: &mut Vec<InlayHin
             }
             collect_hints(body, text, hints);
         }
-        Expression::Statement(inner) => collect_hints(inner, text, hints),
-        Expression::Grouping(inner) => collect_hints(inner, text, hints),
+        Expression::Statement(inner) | Expression::Grouping(inner) => {
+            collect_hints(inner, text, hints);
+        }
         Expression::Block { statements } => {
             for s in statements {
                 collect_hints(s, text, hints);
@@ -294,8 +295,9 @@ fn collect_hints(expr: &ExpressionLocation, text: &str, hints: &mut Vec<InlayHin
                 }
             }
             match body.as_ref() {
-                ForBody::Block(e) => collect_hints(e, text, hints),
-                ForBody::List { expr: e, .. } => collect_hints(e, text, hints),
+                ForBody::Block(e) | ForBody::List { expr: e, .. } => {
+                    collect_hints(e, text, hints);
+                }
                 ForBody::Map {
                     key,
                     value,

ndc_macros/src/function.rs

@@ -69,7 +69,7 @@ pub fn wrap_function(function: &syn::ItemFn) -> syn::Result<Vec<WrappedFunction>
         .map(|(i, function_name)| {
             let ident = format_ident!("{original_identifier}_{i}");
             wrap_single(
-                function.clone(),
+                function,
                 &ident,
                 function_name,
                 &return_type,
@@ -279,7 +279,7 @@ fn map_type_path(p: &syn::TypePath) -> syn::Result<TokenStream> {
 }
 
 fn wrap_single(
-    function: syn::ItemFn,
+    function: &syn::ItemFn,
     identifier: &syn::Ident,
     register_as_function_name: &proc_macro2::Literal,
     return_type: &TokenStream,
@@ -295,7 +295,7 @@ fn wrap_single(
     };
 
     let vm = try_generate_vm_native(
-        &function,
+        function,
         &inner_ident,
         register_as_function_name,
         docs,

ndc_macros/src/types.rs

@@ -176,6 +176,12 @@ fn classify_ref_mut(inner: &syn::Type) -> Option<NdcType> {
     if is_collection_of_vm_value(inner, "Vec") {
         return Some(NdcType::MutVecOfValue);
     }
+    // &mut [Value] — same extraction as &mut Vec<Value>, Rust auto-coerces
+    if let syn::Type::Slice(slice) = inner
+        && classify_owned(&slice.elem) == Some(NdcType::VmValue)
+    {
+        return Some(NdcType::MutVecOfValue);
+    }
     if is_collection_of_vm_value(inner, "HashMap") {
         return Some(NdcType::MutHashMap);
     }

ndc_macros/src/vm_convert.rs

@@ -462,12 +462,13 @@ fn try_vm_return_type(ty: &syn::Type) -> Option<(TokenStream, TokenStream)> {
 /// sense as the Ok type inside a `Result<()>`.
 fn try_vm_return_inner(ty: &syn::Type) -> Option<(TokenStream, TokenStream)> {
     if let syn::Type::Tuple(t) = ty
-        && t.elems.is_empty() {
-            return Some((
-                quote! { Ok(ndc_vm::value::Value::unit()) },
-                quote! { ndc_core::StaticType::Tuple(vec![]) },
-            ));
-        }
+        && t.elems.is_empty()
+    {
+        return Some((
+            quote! { Ok(ndc_vm::value::Value::unit()) },
+            quote! { ndc_core::StaticType::Tuple(vec![]) },
+        ));
+    }
     vm_return_for_classified(ty)
 }
 

ndc_stdlib/src/index.rs

@@ -200,24 +200,25 @@ enum VmOffset {
 
 fn extract_vm_offset(index_value: &Value, size: usize) -> Result<VmOffset, VmError> {
     if let Value::Object(obj) = index_value
-        && let Object::Iterator(iter) = obj.as_ref() {
-            let iter_ref = iter.borrow();
-            if let Some((start, end, inclusive)) = iter_ref.range_bounds() {
-                let from_idx = to_forward_index(start, size, true)?;
-                let to_idx = to_forward_index(end, size, true)?;
-                let to_idx = if inclusive {
-                    (to_idx + 1).min(size)
-                } else {
-                    to_idx
-                };
-                return Ok(VmOffset::Range(from_idx, to_idx));
-            }
-            if let Some(start) = iter_ref.unbounded_range_start() {
-                let from_idx = to_forward_index(start, size, true)?;
-                return Ok(VmOffset::Range(from_idx, size));
-            }
-            return Err(VmError::native("cannot use non-range iterator as index"));
+        && let Object::Iterator(iter) = obj.as_ref()
+    {
+        let iter_ref = iter.borrow();
+        if let Some((start, end, inclusive)) = iter_ref.range_bounds() {
+            let from_idx = to_forward_index(start, size, true)?;
+            let to_idx = to_forward_index(end, size, true)?;
+            let to_idx = if inclusive {
+                (to_idx + 1).min(size)
+            } else {
+                to_idx
+            };
+            return Ok(VmOffset::Range(from_idx, to_idx));
         }
+        if let Some(start) = iter_ref.unbounded_range_start() {
+            let from_idx = to_forward_index(start, size, true)?;
+            return Ok(VmOffset::Range(from_idx, size));
+        }
+        return Err(VmError::native("cannot use non-range iterator as index"));
+    }
     let i = match index_value {
         Value::Int(i) => *i,
         Value::Object(obj) => match obj.as_ref() {
@@ -353,7 +354,7 @@ fn vm_set_at_index(container: &Value, index_value: &Value, rhs: Value) -> Result
     match container {
         Value::Object(obj) => match obj.as_ref() {
             Object::List(list) => {
-                let mut list = list.try_borrow_mut().map_err(|_| {
+                let mut list = list.try_borrow_mut().map_err(|_borrow_err| {
                     VmError::native("Mutation error: you cannot mutate a value in a list while you're iterating over this list")
                 })?;
                 match extract_vm_offset(index_value, size)? {

ndc_stdlib/src/rand.rs

@@ -25,7 +25,7 @@ mod inner {
     use ndc_core::num::Number;
 
     /// Randomly shuffles the elements of the list in place.
-    pub fn shuffle(list: &mut Vec<Value>) {
+    pub fn shuffle(list: &mut [Value]) {
         list.shuffle(&mut rand::rng());
     }