From 1bfba233fc039bdf21f67ccb7186ef8c0d9c9ccb Mon Sep 17 00:00:00 2001 From: Yaroslav Bolyukin Date: Sat, 04 Apr 2026 17:04:54 +0000 Subject: [PATCH] refactor: reenable clippy integer cast checks --- --- a/Cargo.toml +++ b/Cargo.toml @@ -122,11 +122,6 @@ wildcard_imports = "allow" enum_glob_use = "allow" module_name_repetitions = "allow" -# TODO: fix individual issues, however this works as intended almost everywhere -cast_precision_loss = "allow" -cast_possible_wrap = "allow" -cast_possible_truncation = "allow" -cast_sign_loss = "allow" # False positives # https://github.com/rust-lang/rust-clippy/issues/6902 use_self = "allow" --- a/crates/jrsonnet-evaluator/src/arr/mod.rs +++ b/crates/jrsonnet-evaluator/src/arr/mod.rs @@ -128,7 +128,12 @@ #[must_use] pub fn slice(self, index: Option, end: Option, step: Option) -> Self { let get_idx = |pos: Option, len: usize, default| match pos { + #[expect( + clippy::cast_sign_loss, + reason = "abs value is used, len is limited to u31" + )] Some(v) if v < 0 => len.saturating_sub((-v) as usize), + #[expect(clippy::cast_sign_loss, reason = "abs value is used")] Some(v) => (v as usize).min(len), None => default, }; @@ -142,7 +147,9 @@ Self::new(SliceArray { inner: self, + #[expect(clippy::cast_possible_truncation, reason = "len is limited to u31")] from: index as u32, + #[expect(clippy::cast_possible_truncation, reason = "len is limited to u31")] to: end as u32, step: step.get(), }) --- a/crates/jrsonnet-evaluator/src/arr/spec.rs +++ b/crates/jrsonnet-evaluator/src/arr/spec.rs @@ -350,22 +350,26 @@ pub fn new_inclusive(start: i32, end: i32) -> Self { Self { start, end } } + #[expect( + clippy::cast_sign_loss, + reason = "the math is valid with wrapping, sign loss works as intended" + )] + fn size(&self) -> usize { + (self.end as usize) + .wrapping_sub(self.start as usize) + .wrapping_add(1) + } fn range(&self) -> impl ExactSizeIterator + DoubleEndedIterator { - WithExactSize( - self.start..=self.end, - (self.end as usize) - .wrapping_sub(self.start as usize) - .wrapping_add(1), - ) + WithExactSize(self.start..=self.end, self.size()) } } impl ArrayLike for RangeArray { fn len(&self) -> usize { - self.range().len() + self.size() } fn is_empty(&self) -> bool { - self.range().len() == 0 + self.size() == 0 } fn get(&self, index: usize) -> Result> { @@ -431,6 +435,10 @@ fn evaluate(&self, index: usize, value: Val) -> Result { match &self.mapper { ArrayMapper::Plain(f) => f.call(value), + #[expect( + clippy::cast_possible_truncation, + reason = "array len is limited to u31" + )] ArrayMapper::WithIndex(f) => f.call(index as u32, value), } } --- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs +++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs @@ -548,8 +548,18 @@ bail!(FractionalIndex) } if n < 0.0 { - bail!(ArrayBoundsError(n as isize, v.len())); + #[expect( + clippy::cast_possible_truncation, + reason = "it would be truncated anyway" + )] + let n = n as isize; + bail!(ArrayBoundsError(n, v.len())); } + #[expect( + clippy::cast_possible_truncation, + clippy::cast_sign_loss, + reason = "n is checked postive" + )] v.get(n as usize)? .ok_or_else(|| ArrayBoundsError(n as isize, v.len()))? } @@ -568,18 +578,29 @@ bail!(FractionalIndex) } if n < 0.0 { - bail!(ArrayBoundsError(n as isize, s.into_flat().chars().count())); + #[expect( + clippy::cast_possible_truncation, + reason = "it would be truncated anyway" + )] + let n = n as isize; + bail!(ArrayBoundsError(n, s.into_flat().chars().count())); } + #[expect( + clippy::cast_sign_loss, + clippy::cast_possible_truncation, + reason = "n is positive, overflow will truncate as expected" + )] + let n = n as usize; let v: IStr = s .clone() .into_flat() .chars() - .skip(n as usize) + .skip(n) .take(1) .collect::() .into(); if v.is_empty() { - bail!(StringBoundsError(n as usize, s.into_flat().chars().count())) + bail!(StringBoundsError(n, s.into_flat().chars().count())) } StrValue::Flat(v) }), --- a/crates/jrsonnet-evaluator/src/evaluate/operator.rs +++ b/crates/jrsonnet-evaluator/src/evaluate/operator.rs @@ -20,7 +20,8 @@ (Plus, Num(n)) => Val::Num(*n), (Minus, Num(n)) => Val::try_num(-n.get())?, (Not, Bool(v)) => Bool(!v), - (BitNot, Num(n)) => Val::try_num(!(n.get() as i64) as f64)?, + #[expect(clippy::cast_precision_loss, reason = "as spec")] + (BitNot, Num(n)) => Val::try_num(!n.truncate_for_bitwise()? as f64)?, (op, o) => bail!(UnaryOperatorDoesNotOperateOnType(op, o.value_type())), }) } @@ -73,7 +74,17 @@ pub fn evaluate_mul_op(a: &Val, b: &Val) -> Result { use Val::*; Ok(match (a, b) { + #[expect( + clippy::cast_possible_truncation, + clippy::cast_sign_loss, + reason = "should not be used with values too large, negative == 0" + )] (Str(s), Num(c)) => Val::string(s.to_string().repeat(c.get() as usize)), + #[expect( + clippy::cast_possible_truncation, + clippy::cast_sign_loss, + reason = "should not be used with values too large" + )] (Num(c), Str(s)) => Val::string(s.to_string().repeat(c.get() as usize)), (Num(v1), Num(v2)) => Val::try_num(v1.get() * v2.get())?, @@ -218,13 +229,28 @@ (a, Div, b) => evaluate_div_op(a, b)?, (a, Mod, b) => evaluate_mod_op(a, b)?, - (Num(v1), BitAnd, Num(v2)) => { + (Num(v1), BitAnd, Num(v2)) => + { + #[expect( + clippy::cast_precision_loss, + reason = "values are within safe integer ranges" + )] Val::try_num((v1.truncate_for_bitwise()? & v2.truncate_for_bitwise()?) as f64)? } - (Num(v1), BitOr, Num(v2)) => { + (Num(v1), BitOr, Num(v2)) => + { + #[expect( + clippy::cast_precision_loss, + reason = "values are within safe integer ranges" + )] Val::try_num((v1.truncate_for_bitwise()? | v2.truncate_for_bitwise()?) as f64)? } - (Num(v1), BitXor, Num(v2)) => { + (Num(v1), BitXor, Num(v2)) => + { + #[expect( + clippy::cast_precision_loss, + reason = "values are within safe integer ranges" + )] Val::try_num((v1.truncate_for_bitwise()? ^ v2.truncate_for_bitwise()?) as f64)? } (Num(v1), Lhs, Num(v2)) => { @@ -234,16 +260,28 @@ let base = v1.truncate_for_bitwise()?; let exp = v2.truncate_for_bitwise()? % 64; + #[expect(clippy::cast_sign_loss, reason = "exp is positive")] if exp >= 1 && base >= (1i64 << (63 - exp as u32)) { bail!("left shift would overflow") } + #[expect( + clippy::cast_precision_loss, + clippy::cast_sign_loss, + reason = "checked as original impl" + )] Val::try_num(base.wrapping_shl(exp as u32) as f64)? } (Num(v1), Rhs, Num(v2)) => { if v2.get() < 0.0 { bail!("shift by negative exponent") } + #[expect( + clippy::cast_sign_loss, + clippy::cast_possible_truncation, + reason = "checked as original impl" + )] let exp = ((v2.get() as i64) & 63) as u32; + #[expect(clippy::cast_precision_loss, reason = "checked as upstream impl")] Val::try_num(v1.truncate_for_bitwise()?.wrapping_shr(exp) as f64)? } --- a/crates/jrsonnet-evaluator/src/integrations/serde.rs +++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs @@ -69,12 +69,20 @@ where E: de::Error, { + #[expect( + clippy::cast_precision_loss, + reason = "this is how it works with stdlib functions" + )] Ok(Val::Num(NumValue::new(v as f64).expect("no overflow"))) } fn visit_u64(self, v: u64) -> Result where E: de::Error, { + #[expect( + clippy::cast_precision_loss, + reason = "this is how it works with stdlib functions" + )] Ok(Val::Num(NumValue::new(v as f64).expect("no overflow"))) } @@ -161,6 +169,10 @@ Self::Num(n) => { let n = n.get(); if n.fract() == 0.0 { + #[expect( + clippy::cast_possible_truncation, + reason = "no correct implementation is possible here; expected" + )] let n = n as i64; serializer.serialize_i64(n) } else { --- a/crates/jrsonnet-evaluator/src/obj/mod.rs +++ b/crates/jrsonnet-evaluator/src/obj/mod.rs @@ -792,6 +792,8 @@ key, }) } + + #[allow(dead_code, reason = "used in object ...rest destructuring")] pub(crate) fn as_standalone(&self) -> StandaloneSuperCore { StandaloneSuperCore { sup: CoreIdx { --- a/crates/jrsonnet-evaluator/src/stdlib/format.rs +++ b/crates/jrsonnet-evaluator/src/stdlib/format.rs @@ -1,5 +1,10 @@ //! faster std.format impl #![allow(clippy::too_many_arguments)] +#![expect( + clippy::cast_possible_truncation, + clippy::cast_sign_loss, + reason = "many safe integer casts, behavior on overflow is not specified" +)] use jrsonnet_gcmodule::Trace; use jrsonnet_interner::IStr; --- a/crates/jrsonnet-evaluator/src/trace/mod.rs +++ b/crates/jrsonnet-evaluator/src/trace/mod.rs @@ -129,6 +129,7 @@ } else { false }; + #[expect(clippy::cast_possible_truncation, reason = "code is limited by 4gb")] let mut location = path .map_source_locations(&[offset as u32]) .into_iter() --- a/crates/jrsonnet-evaluator/src/typed/conversions.rs +++ b/crates/jrsonnet-evaluator/src/typed/conversions.rs @@ -157,7 +157,9 @@ } } +#[expect(clippy::cast_precision_loss, reason = "checked to not overflow")] pub const MAX_SAFE_INTEGER: f64 = ((1u64 << (f64::MANTISSA_DIGITS)) - 1) as f64; +#[expect(clippy::cast_precision_loss, reason = "checked to not overflow")] pub const MIN_SAFE_INTEGER: f64 = (-((1i64 << (f64::MANTISSA_DIGITS)) - 1)) as f64; macro_rules! impl_int { @@ -179,6 +181,7 @@ stringify!($ty) ) } + #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation, reason = "checked by TYPE")] Ok(n as Self) } _ => unreachable!(), @@ -198,6 +201,7 @@ macro_rules! impl_bounded_int { ($($name:ident = $ty:ty)*) => {$( #[derive(Clone, Copy)] + #[allow(clippy::cast_possible_truncation, reason = "overflow is api misuse")] pub struct $name($ty); impl $name { pub const fn new(value: $ty) -> Option<$name> { @@ -219,6 +223,7 @@ } impl Typed for $name { + #[allow(clippy::cast_possible_truncation, clippy::cast_precision_loss, reason = "overflow is api misuse")] const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber( Some(MIN as f64), @@ -239,6 +244,7 @@ stringify!($ty) ) } + #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss, reason = "overflow is api misuse, the range is checked by TYPE")] Ok(Self(n as $ty)) } _ => unreachable!(), @@ -318,6 +324,11 @@ if n.trunc() != n { bail!("cannot convert number with fractional part to usize") } + #[allow( + clippy::cast_possible_truncation, + clippy::cast_sign_loss, + reason = "the range is checked by TYPE" + )] Ok(n as Self) } _ => unreachable!(), --- a/crates/jrsonnet-evaluator/src/val.rs +++ b/crates/jrsonnet-evaluator/src/val.rs @@ -295,8 +295,10 @@ }; let mut get_idx = |pos: Option, default| { match pos { - Some(v) if v < 0 => get_len().saturating_sub((-v) as usize), + #[expect(clippy::cast_sign_loss, reason = "abs value is used")] + Some(v) if v < 0 => get_len().saturating_sub((-v as isize) as usize), // No need to clamp, as iterator interface is used + #[expect(clippy::cast_sign_loss, reason = "abs value is used")] Some(v) => v as usize, None => default, } @@ -322,6 +324,10 @@ Self::Arr(arr) => Ok(Self::Arr(arr.clone().slice( index, end, + #[expect( + clippy::cast_possible_truncation, + reason = "overflow will result with skip too large which would be equivalent" + )] step.map(|v| NonZeroU32::new(v.value() as u32).expect("bounded != 0")), ))), } @@ -446,6 +452,7 @@ if self.0 < MIN_SAFE_INTEGER || self.0 > MAX_SAFE_INTEGER { bail!("numberic value outside of safe integer range for bitwise operation"); } + #[expect(clippy::cast_possible_truncation, reason = "intended")] Ok(self.0 as i64) } } @@ -520,6 +527,7 @@ type Error = ConvertNumValueError; #[inline] fn try_from(value: $ty) -> Result { + #[expect(clippy::cast_precision_loss, reason = "precision loss is explicitly handled")] let value = value as f64; if value < MIN_SAFE_INTEGER { return Err(ConvertNumValueError::Underflow) --- a/crates/jrsonnet-interner/src/inner.rs +++ b/crates/jrsonnet-interner/src/inner.rs @@ -67,7 +67,7 @@ .cast(); assert!(!data.is_null()); *data = InnerHeader::new(bytes.len().try_into().expect("bytes > 4GB"), is_utf8); - ptr::copy_nonoverlapping(bytes.as_ptr(), data.offset(1).cast::(), bytes.len()); + ptr::copy_nonoverlapping(bytes.as_ptr(), data.add(1).cast::(), bytes.len()); Self(UnsafeCell::new(NonNull::new_unchecked(data))) } } @@ -89,10 +89,7 @@ let size = unsafe { (*header).size }; // SAFETY: bytes after data is allocated to be exactly data.size in length unsafe { - slice::from_raw_parts( - (*self.0.get()).as_ptr().offset(1).cast::(), - size as usize, - ) + slice::from_raw_parts((*self.0.get()).as_ptr().add(1).cast::(), size as usize) } } @@ -156,7 +153,7 @@ } pub fn as_ptr(this: &Self) -> *const u8 { // SAFETY: data is initialized - unsafe { (*this.0.get()).as_ptr().offset(1).cast() } + unsafe { (*this.0.get()).as_ptr().add(1).cast() } } pub fn strong_count(this: &Self) -> u32 { --- a/crates/jrsonnet-ir-parser/src/lib.rs +++ b/crates/jrsonnet-ir-parser/src/lib.rs @@ -638,6 +638,7 @@ } } +#[allow(clippy::too_many_lines)] fn expr_basic(p: &mut Parser<'_>) -> Result { if let Some(lit) = literal(p) { return Ok(Expr::Literal(lit)); @@ -764,7 +765,6 @@ } SyntaxKind::IDENT => { - let text = p.text(); let n = spanned(p, |p| { let s: IStr = p.text().into(); p.eat_any(); @@ -1005,8 +1005,9 @@ } pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned { - let len = s.len(); - Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len as u32)) + let len = u32::try_from(s.len()).expect("code size is limited by 4gb"); + + Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len)) } #[cfg(test)] --- a/crates/jrsonnet-lexer/src/lex.rs +++ b/crates/jrsonnet-lexer/src/lex.rs @@ -60,7 +60,10 @@ range: { let Range { start, end } = self.inner.span(); - Span(start as u32, end as u32) + Span( + u32::try_from(start).expect("code size is limited by 4gb"), + u32::try_from(end).expect("code size is limited by 4gb"), + ) }, }) } --- a/crates/jrsonnet-stdlib/src/arrays.rs +++ b/crates/jrsonnet-stdlib/src/arrays.rs @@ -17,7 +17,11 @@ } #[builtin] -pub fn builtin_make_array(sz: BoundedI32<0, { i32::MAX }>, func: FuncVal) -> Result { +pub fn builtin_make_array( + // Can't use usize because range_exclusive is over i32 + sz: BoundedI32<0, { i32::MAX }>, + func: FuncVal, +) -> Result { if *sz == 0 { return Ok(ArrValue::empty()); } @@ -25,6 +29,7 @@ // TODO: Different mapped array impl avoiding allocating unnecessary vals || Ok(ArrValue::range_exclusive(0, *sz).map(FromUntyped::from_untyped(Val::Func(func))?)), |trivial| { + #[expect(clippy::cast_sign_loss, reason = "sz is bounded to be larger than 0")] let mut out = Vec::with_capacity(*sz as usize); for _ in 0..*sz { out.push(trivial.clone()); @@ -363,6 +368,10 @@ if arr.is_empty() { return eval_on_empty(onEmpty); } + #[expect( + clippy::cast_precision_loss, + reason = "array sizes are bounded to i32 len" + )] Ok(Val::try_num(arr.iter().sum::() / (arr.len() as f64))?) } @@ -378,6 +387,11 @@ pub fn builtin_remove(arr: ArrValue, elem: Val) -> Result { for (index, item) in arr.iter().enumerate() { if equals(&item?, &elem)? { + #[expect( + clippy::cast_possible_truncation, + clippy::cast_possible_wrap, + reason = "array sizes are bounded to i32 len" + )] return builtin_remove_at(arr.clone(), index as i32); } } --- a/crates/jrsonnet-stdlib/src/math.rs +++ b/crates/jrsonnet-stdlib/src/math.rs @@ -120,6 +120,7 @@ let lg = s.abs().log2(); let x = (lg - lg.floor() - 1.0).exp2(); let exp = lg.floor() + 1.0; + #[expect(clippy::cast_possible_truncation, reason = "exponent can fit in i16")] (s.signum() * x, exp as i16) } } --- a/flake.nix +++ b/flake.nix @@ -66,6 +66,7 @@ "clippy" "rustc" "rust-src" + "rust-analyzer" ]) rustfmt ]; -- gitstuff