chore(dev): more tricky clippy fixes (#1237)

* chore(dev): deny cast_sign_loss

* deny clippy::cast_precision_loss

* start reverting breaking changes, should do it step by step

* cargo fmt

* removed all breaking changes, replaced with allows

* cargo fmt

* a few more

* cargo fmt

* move comment above #allow, cargo fmt moved it...

src/stdlib/encode_gzip.rs

@@ -11,6 +11,8 @@ fn encode_gzip(value: Value, compression_level: Option<Value>) -> Resolved {
     let compression_level = match compression_level {
         None => flate2::Compression::default(),
         Some(value) => {
+            // TODO consider removal options
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
             let level = value.try_integer()? as u32;
             if level > MAX_COMPRESSION_LEVEL {
                 return Err(format!("compression level must be <= {MAX_COMPRESSION_LEVEL}").into());

src/stdlib/encode_zlib.rs

@@ -11,6 +11,8 @@ fn encode_zlib(value: Value, compression_level: Option<Value>) -> Resolved {
     let compression_level = match compression_level {
         None => flate2::Compression::default(),
         Some(value) => {
+            // TODO consider removal options
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
             let level = value.try_integer()? as u32;
             if level > MAX_COMPRESSION_LEVEL {
                 return Err(format!("compression level must be <= {MAX_COMPRESSION_LEVEL}").into());

src/stdlib/encode_zstd.rs

@@ -4,6 +4,7 @@ use nom::AsBytes;
 fn encode_zstd(value: Value, compression_level: Option<Value>) -> Resolved {
     let compression_level = match compression_level {
         None => 0,
+        #[allow(clippy::cast_possible_truncation)] //TODO evaluate removal options
         Some(value) => value.try_integer()? as i32,
     };
 

src/stdlib/find.rs

@@ -2,6 +2,8 @@ use crate::compiler::prelude::*;
 
 #[allow(clippy::cast_possible_wrap)]
 fn find(value: Value, pattern: Value, from: Option<Value>) -> Resolved {
+    // TODO consider removal options
+    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
     let from = match from {
         Some(value) => value.try_integer()?,
         None => 0,

src/stdlib/format_int.rs

@@ -2,6 +2,7 @@ use std::collections::VecDeque;
 
 use crate::compiler::prelude::*;
 
+#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)] // TODO consider removal options
 fn format_int(value: Value, base: Option<Value>) -> Resolved {
     let value = value.try_integer()?;
     let base = match base {
@@ -106,6 +107,7 @@ impl FunctionExpression for FormatIntFn {
 // Formats x in the provided radix
 //
 // Panics if radix is < 2 or > 36
+#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)] // TODO consider removal options
 fn format_radix(x: i64, radix: u32) -> String {
     let mut result: VecDeque<char> = VecDeque::new();
 

src/stdlib/format_number.rs

@@ -41,6 +41,8 @@ fn format_number(
     match scale {
         Some(0) => parts.truncate(1),
         Some(i) => {
+            // TODO consider removal options
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
             let i = i as usize;
 
             if parts.len() == 1 {

src/stdlib/get.rs

@@ -1,6 +1,7 @@
 use crate::compiler::prelude::*;
 use crate::path::{OwnedSegment, OwnedValuePath};
 
+#[allow(clippy::cast_possible_truncation)] // TODO consider removal options
 fn get(value: Value, value_path: Value) -> Resolved {
     let path = match value_path {
         Value::Array(array) => {

src/stdlib/match_datadog_query.rs

@@ -301,6 +301,7 @@ impl Filter<Value> for VrlFilter {
         })
     }
 
+    #[allow(clippy::cast_precision_loss)] //TODO evaluate removal options
     fn compare(
         &self,
         field: Field,

src/stdlib/mod.rs

@@ -1,9 +1,6 @@
 #![deny(warnings, clippy::pedantic)]
 #![allow(
     deprecated,
-    clippy::cast_possible_truncation, // allowed in initial deny commit
-    clippy::cast_precision_loss, // allowed in initial deny commit
-    clippy::cast_sign_loss, // allowed in initial deny commit
     clippy::needless_pass_by_value, // allowed in initial deny commit
 )]
 

src/stdlib/parse_etld.rs

@@ -137,6 +137,8 @@ impl FunctionExpression for ParseEtldFn {
 
         let plus_parts = match self.plus_parts.resolve(ctx)?.try_integer()? {
             x if x < 0 => 0,
+            // TODO consider removal options
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
             x => x as usize,
         };
 

src/stdlib/parse_influxdb.rs

@@ -6,6 +6,7 @@ use influxdb_line_protocol::{FieldValue, ParsedLine};
 use crate::compiler::prelude::*;
 use crate::{btreemap, value};
 
+#[allow(clippy::cast_precision_loss)] //TODO evaluate removal options
 fn influxdb_line_to_metrics(line: ParsedLine) -> Result<Vec<ObjectMap>, ExpressionError> {
     let ParsedLine {
         series,

src/stdlib/parse_int.rs

@@ -12,6 +12,8 @@ fn parse_int(value: Value, base: Option<Value>) -> Resolved {
                 )
                 .into());
             }
+            // TODO consider removal options
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
             (base as u32, 0)
         }
         None => match string.chars().next() {

src/stdlib/parse_json.rs

@@ -84,14 +84,15 @@ fn parse_layer(value: &RawValue, remaining_depth: u8) -> std::result::Result<Jso
 
 fn validate_depth(value: Value) -> ExpressionResult<u8> {
     let res = value.try_integer()?;
+    let res = u8::try_from(res).map_err(|e| e.to_string())?;
 
     // The lower cap is 1 because it is pointless to use anything lower,
     // because 'data = parse_json!(.message, max_depth: 0)' equals to 'data = .message'.
     //
     // The upper cap is 128 because serde_json has the same recursion limit by default.
     // https://github.com/serde-rs/json/blob/4d57ebeea8d791b8a51c229552d2d480415d00e6/json/src/de.rs#L111
     if (1..=128).contains(&res) {
-        Ok(res as u8)
+        Ok(res)
     } else {
         Err(ExpressionError::from(format!(
             "max_depth value should be greater than 0 and less than 128, got {res}"

src/stdlib/random_bytes.rs

@@ -68,6 +68,8 @@ fn get_length(value: Value) -> std::result::Result<usize, &'static str> {
     if length > MAX_LENGTH {
         return Err(LENGTH_TOO_LARGE_ERR);
     }
+    // TODO consider removal options
+    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
     Ok(length as usize)
 }
 

src/stdlib/remove.rs

@@ -11,6 +11,7 @@ fn remove(path: Value, compact: Value, mut value: Value) -> Resolved {
                     Value::Bytes(field) => {
                         OwnedSegment::Field(String::from_utf8_lossy(&field).into())
                     }
+                    #[allow(clippy::cast_possible_truncation)] //TODO evaluate removal options
                     Value::Integer(index) => OwnedSegment::Index(index as isize),
                     value => {
                         return Err(format!(

src/stdlib/replace.rs

@@ -1,5 +1,6 @@
 use crate::compiler::prelude::*;
 
+#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)] // TODO consider removal options
 fn replace(value: Value, with_value: Value, count: Value, pattern: Value) -> Resolved {
     let value = value.try_bytes_utf8_lossy()?;
     let with = with_value.try_bytes_utf8_lossy()?;

src/stdlib/replace_with.rs

@@ -16,6 +16,8 @@ where
 {
     let haystack = value.try_bytes_utf8_lossy()?;
     let count = match count.try_integer()? {
+        // TODO consider removal options
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         i if i > 0 => i as usize,
         i if i < 0 => 0,
         // this is when i == 0

src/stdlib/set.rs

@@ -11,6 +11,7 @@ fn set(path: Value, mut value: Value, data: Value) -> Resolved {
                     Value::Bytes(path) => {
                         OwnedSegment::Field(String::from_utf8_lossy(&path).into())
                     }
+                    #[allow(clippy::cast_possible_truncation)] //TODO evaluate removal options
                     Value::Integer(index) => OwnedSegment::Index(index as isize),
                     value => {
                         return Err(format!(

src/stdlib/slice.rs

@@ -3,6 +3,8 @@ use std::ops::Range;
 use crate::compiler::prelude::*;
 
 #[allow(clippy::cast_possible_wrap)]
+#[allow(clippy::cast_sign_loss)]
+#[allow(clippy::cast_possible_truncation)] //TODO evaluate removal options
 fn slice(start: i64, end: Option<i64>, value: Value) -> Resolved {
     let range = |len: i64| -> ExpressionResult<Range<usize>> {
         let start = match start {

src/stdlib/split.rs

@@ -4,6 +4,8 @@ fn split(value: Value, limit: Value, pattern: Value) -> Resolved {
     let string = value.try_bytes_utf8_lossy()?;
     let limit = match limit.try_integer()? {
         x if x < 0 => 0,
+        // TODO consider removal options
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         x => x as usize,
     };
     match pattern {

src/stdlib/to_float.rs

@@ -7,6 +7,7 @@ pub(crate) fn bytes_to_float(bytes: Bytes) -> Resolved {
         .map_err(|e| e.to_string().into())
 }
 
+#[allow(clippy::cast_precision_loss)] //TODO evaluate removal options
 fn to_float(value: Value) -> Resolved {
     use Value::{Boolean, Bytes, Float, Integer, Null, Timestamp};
     match value {

src/stdlib/to_int.rs

@@ -6,6 +6,7 @@ fn to_int(value: Value) -> Resolved {
 
     match value {
         Integer(_) => Ok(value),
+        #[allow(clippy::cast_possible_truncation)] //TODO evaluate removal options
         Float(v) => Ok(Integer(v.into_inner() as i64)),
         Boolean(v) => Ok(Integer(i64::from(v))),
         Null => Ok(0.into()),

src/stdlib/truncate.rs

@@ -3,6 +3,8 @@ use crate::compiler::prelude::*;
 fn truncate(value: Value, limit: Value, suffix: Value) -> Resolved {
     let mut value = value.try_bytes_utf8_lossy()?.into_owned();
     let limit = limit.try_integer()?;
+    // TODO consider removal options
+    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
     let limit = if limit < 0 { 0 } else { limit as usize };
     let suffix = suffix.try_bytes_utf8_lossy()?.to_string();
     let pos = if let Some((pos, chr)) = value.char_indices().take(limit).last() {

src/stdlib/util.rs

@@ -5,6 +5,7 @@ use crate::value::{KeyString, ObjectMap, Value};
 /// Takes a function parameter so the exact rounding function (ceil, floor or round)
 /// can be specified.
 #[inline]
+#[allow(clippy::cast_precision_loss)] //TODO evaluate removal options
 pub(crate) fn round_to_precision<F>(num: f64, precision: i64, fun: F) -> f64
 where
     F: Fn(f64) -> f64,

src/stdlib/uuid_v7.rs

@@ -3,6 +3,7 @@ use bytes::Bytes;
 use chrono::{DateTime, Utc};
 use uuid::{timestamp::Timestamp, NoContext};
 
+#[allow(clippy::cast_sign_loss)] // TODO consider removal options
 fn uuid_v7(timestamp: Option<Value>) -> Resolved {
     let utc_timestamp: DateTime<Utc> = if let Some(timestamp) = timestamp {
         timestamp.try_timestamp()?
@@ -12,6 +13,7 @@ fn uuid_v7(timestamp: Option<Value>) -> Resolved {
 
     let seconds = utc_timestamp.timestamp() as u64;
     let nanoseconds = match utc_timestamp.timestamp_nanos_opt() {
+        #[allow(clippy::cast_possible_truncation)] //TODO evaluate removal options
         Some(nanos) => nanos as u32,
         None => return Err(ValueError::OutOfRange(Kind::timestamp()).into()),
     };

src/value/value/serde.rs

@@ -107,7 +107,7 @@ impl<'de> Deserialize<'de> for Value {
                     Ok(value.into())
                 } else {
                     // TODO: Address this issue by providing a lossless conversion option.
-                    #[allow(clippy::cast_precision_loss)]
+                    #[allow(clippy::cast_precision_loss)] //TODO evaluate removal options
                     let converted_value = value as f64;
                     let wrapped_value = NotNan::new(converted_value).map_err(|_| {
                         SerdeError::invalid_value(