Migrate to edition 2024

Author: marmeladema

Cargo.lock

@@ -425,7 +425,7 @@ impl<'s> Expr<'s> for ComparisonExpr<'s> {
         let lhs = self.lhs;
 
         macro_rules! cast_value {
-            ($value:expr, $ty:ident) => {
+            ($value:expr_2021, $ty:ident) => {
                 match $value {
                     LhsValue::$ty(value) => value,
                     _ => unreachable!(),
@@ -482,7 +482,7 @@ impl<'s> Expr<'s> for ComparisonExpr<'s> {
             }),
             ComparisonOpExpr::Contains(bytes) => {
                 macro_rules! search {
-                    ($searcher:expr) => {{
+                    ($searcher:expr_2021) => {{
                         let searcher = $searcher;
                         lhs.compile_with(compiler, false, move |x, _ctx| {
                             searcher.search_in(cast_value!(x, Bytes).as_ref())

engine/src/ast/field_expr.rs

@@ -115,13 +115,13 @@ impl<'i, 's> LexWith<'i, &FilterParser<'s>> for FunctionCallArgExpr<'s> {
 
         macro_rules! c_is_field {
             // characters above F/f in the alphabet mean it can't be a decimal or hex int
-            ($c:expr) => {
+            ($c:expr_2021) => {
                 (($c.is_ascii_alphanumeric() && !$c.is_ascii_hexdigit()) || $c == '_')
             };
         }
 
         macro_rules! c_is_field_or_int {
-            ($c:expr) => {
+            ($c:expr_2021) => {
                 ($c.is_ascii_alphanumeric() || $c == '_')
             };
         }
@@ -343,11 +343,12 @@ impl<'s> ValueExpr<'s> for FunctionCallExpr<'s> {
             }
         } else {
             CompiledValueExpr::new(move |ctx| {
-                if let Some(value) = call(&mut args.iter().map(|arg| arg.execute(ctx))) {
-                    debug_assert!(value.get_type() == return_type);
-                    Ok(value)
-                } else {
-                    Err(return_type)
+                match call(&mut args.iter().map(|arg| arg.execute(ctx))) {
+                    Some(value) => {
+                        debug_assert!(value.get_type() == return_type);
+                        Ok(value)
+                    }
+                    _ => Err(return_type),
                 }
             })
         }

engine/src/ast/function_expr.rs

@@ -280,10 +280,13 @@ impl<'s> IndexExpr<'s> {
                 let call = compiler.compile_function_call_expr(call);
                 CompiledVecExpr::new(move |ctx| {
                     let mut iter = MapEachIterator::from_indexes(&indexes[..]);
-                    if let Ok(val) = call.execute(ctx) {
-                        iter.reset(val);
-                    } else {
-                        return TypedArray::default();
+                    match call.execute(ctx) {
+                        Ok(val) => {
+                            iter.reset(val);
+                        }
+                        _ => {
+                            return TypedArray::default();
+                        }
                     }
 
                     TypedArray::from_iter(iter.map(|item| func(&item, ctx)))

engine/src/ast/index_expr.rs

@@ -69,7 +69,7 @@ pub enum LogicalExpr<'s> {
 impl GetType for LogicalExpr<'_> {
     fn get_type(&self) -> Type {
         match &self {
-            LogicalExpr::Combining { ref items, .. } => items[0].get_type(),
+            LogicalExpr::Combining { items, .. } => items[0].get_type(),
             LogicalExpr::Comparison(comparison) => comparison.get_type(),
             LogicalExpr::Parenthesized(parenthesized) => parenthesized.expr.get_type(),
             LogicalExpr::Unary { arg, .. } => arg.get_type(),

engine/src/ast/logical_expr.rs

@@ -193,7 +193,7 @@ impl<'a> FunctionParam<'a> {
     /// Returns the underlying type if the current parameter is a variable, otherwise an error.
     pub fn as_variable(&self) -> Result<&Type, FunctionArgKindMismatchError> {
         match self {
-            Self::Variable(ref ty) => Ok(ty),
+            Self::Variable(ty) => Ok(ty),
             Self::Constant(_) => Err(FunctionArgKindMismatchError {
                 expected: FunctionArgKind::Field,
                 actual: FunctionArgKind::Literal,

engine/src/functions.rs

@@ -227,7 +227,7 @@ macro_rules! lex_enum {
     // On the parser side, tries to parse either of the given string values,
     // and returns the variant if any of them succeeded.
     (@decl $preamble:tt $name:ident $input:ident { $($decl:tt)* } { $($expr:tt)* } {
-        $(#[$meta:meta])* $($s:literal)|+ => $item:ident $(= $value:expr)*,
+        $(#[$meta:meta])* $($s:literal)|+ => $item:ident $(= $value:expr_2021)*,
         $($rest:tt)*
     }) => {
         lex_enum!(@decl $preamble $name $input {
@@ -324,27 +324,27 @@ pub fn complete<T>(res: LexResult<'_, T>) -> Result<T, LexError<'_>> {
 
 #[cfg(test)]
 macro_rules! assert_ok {
-    ($s:expr, $res:expr, $rest:expr) => {{
+    ($s:expr_2021, $res:expr_2021, $rest:expr_2021) => {{
         let expr = $s.unwrap();
         assert_eq!(expr, ($res, $rest));
         expr.0
     }};
 
-    ($s:expr, $res:expr) => {
+    ($s:expr_2021, $res:expr_2021) => {
         assert_ok!($s, $res, "")
     };
 }
 
 #[cfg(test)]
 macro_rules! assert_err {
-    ($s:expr, $kind:expr, $span:expr) => {
+    ($s:expr_2021, $kind:expr_2021, $span:expr_2021) => {
         assert_eq!($s, Err(($kind, $span)))
     };
 }
 
 #[cfg(test)]
 macro_rules! assert_json {
-    ($expr:expr, $json:tt) => {{
+    ($expr:expr_2021, $json:tt) => {{
         let json = ::serde_json::to_value(&$expr).unwrap();
         assert_eq!(json, ::serde_json::json!($json));
         json

engine/src/lex.rs

@@ -470,7 +470,7 @@ impl<'a, 'b> ArrayMut<'a, 'b> {
     /// Get a mutable reference to an element if it exists
     #[inline]
     pub fn get_mut(&'a mut self, idx: usize) -> Option<LhsValueMut<'a, 'b>> {
-        self.0.get_mut(idx).map(LhsValueMut::from)
+        self.0.get_mut(idx)
     }
 }
 

engine/src/lhs_types/array.rs

@@ -444,7 +444,7 @@ impl<'a, 'b> MapMut<'a, 'b> {
     /// Get a mutable reference to an element if it exists
     #[inline]
     pub fn get_mut(&'a mut self, key: &[u8]) -> Option<LhsValueMut<'a, 'b>> {
-        self.0.get_mut(key).map(LhsValueMut::from)
+        self.0.get_mut(key)
     }
 
     /// Inserts an element, overwriting if one already exists

engine/src/lhs_types/map.rs

@@ -105,15 +105,15 @@ impl Lex<'_> for IpRange {
 }
 
 macro_rules! impl_ip_range_from {
-    (@single $v:ident, |$input:ident: $ty:ty| $transform:expr) => {
+    (@single $v:ident, |$input:ident: $ty:ty| $transform:expr_2021) => {
         impl From<$ty> for ExplicitIpRange {
             fn from($input: $ty) -> Self {
                 ExplicitIpRange::$v($transform)
             }
         }
     };
 
-    ($ty:ident { $v4:ty, $v6:ty }, |$input:ident| $transform:expr) => {
+    ($ty:ident { $v4:ty, $v6:ty }, |$input:ident| $transform:expr_2021) => {
         impl_ip_range_from!(@single V4, |$input: $v4| $transform);
         impl_ip_range_from!(@single V6, |$input: $v6| $transform);