hecks 3.14.0 → 4.0.0

data/rust/parser/src/expr/ast_json.rs

@@ -20,10 +20,22 @@ fn op_tag(name: &str) -> (&'static str, JsonValue) {
 
 fn emit_bool(node: &Evaluator) -> JsonValue {
     match node {
-        Evaluator::Or(left, right) => obj(vec![op_tag("or"), ("left", emit_bool(left)), ("right", emit_bool(right))]),
-        Evaluator::And(left, right) => obj(vec![op_tag("and"), ("left", emit_bool(left)), ("right", emit_bool(right))]),
+        Evaluator::Or(left, right) => obj(vec![
+            op_tag("or"),
+            ("left", emit_bool(left)),
+            ("right", emit_bool(right)),
+        ]),
+        Evaluator::And(left, right) => obj(vec![
+            op_tag("and"),
+            ("left", emit_bool(left)),
+            ("right", emit_bool(right)),
+        ]),
         Evaluator::Not(inner) => obj(vec![op_tag("not"), ("expr", emit_bool(inner))]),
-        Evaluator::Compare { operator, left, right } => obj(vec![
+        Evaluator::Compare {
+            operator,
+            left,
+            right,
+        } => obj(vec![
             op_tag("compare"),
             ("cmp", emit_comparison(operator)),
             ("left", emit_resolver(left)),
@@ -44,13 +56,13 @@ fn emit_comparison(operator: &Operator) -> JsonValue {
 
 fn emit_include(haystack: &Resolver, needle: &Resolver) -> JsonValue {
     let Resolver::ArrayLiteral(elements) = haystack else {
-        return obj(vec![op_tag("include"), ("haystack", emit_resolver(haystack)), ("needle", emit_resolver(needle))]);
+        return obj(vec![
+            op_tag("include"),
+            ("haystack", emit_resolver(haystack)),
+            ("needle", emit_resolver(needle)),
+        ]);
     };
 
-    if elements.is_empty() {
-        return obj(vec![op_tag("bool"), ("value", JsonValue::Bool(false))]);
-    }
-
     let eq = find_operator("==");
     elements
         .iter()
@@ -63,81 +75,161 @@ fn emit_include(haystack: &Resolver, needle: &Resolver) -> JsonValue {
             ])
         })
         .reduce(|left, right| obj(vec![op_tag("or"), ("left", left), ("right", right)]))
-        .expect("non-empty by the guard above")
+        .unwrap_or_else(|| obj(vec![op_tag("bool"), ("value", JsonValue::Bool(false))]))
 }
 
 pub fn emit_resolver(node: &Resolver) -> JsonValue {
     match node {
-        Resolver::IntegerLiteral(v) => obj(vec![op_tag("int"), ("value", JsonValue::Number(v.to_string()))]),
-        Resolver::FloatLiteral(v) => obj(vec![op_tag("float"), ("value", JsonValue::Number(ruby_float(*v)))]),
-        Resolver::StringLiteral(v) => obj(vec![op_tag("str"), ("value", JsonValue::String(v.clone()))]),
+        Resolver::IntegerLiteral(v) => obj(vec![
+            op_tag("int"),
+            ("value", JsonValue::Number(v.to_string())),
+        ]),
+        Resolver::FloatLiteral(v) => obj(vec![
+            op_tag("float"),
+            ("value", JsonValue::Number(ruby_float(*v))),
+        ]),
+        Resolver::StringLiteral(v) => {
+            obj(vec![op_tag("str"), ("value", JsonValue::String(v.clone()))])
+        }
         Resolver::BoolLiteral(v) => obj(vec![op_tag("bool"), ("value", JsonValue::Bool(*v))]),
         Resolver::NilLiteral => obj(vec![op_tag("nil")]),
         Resolver::Lookup(path) => obj(vec![
             op_tag("lookup"),
-            ("path", JsonValue::Array(path.split('.').map(|s| JsonValue::String(s.to_string())).collect())),
+            (
+                "path",
+                JsonValue::Array(
+                    path.split('.')
+                        .map(|s| JsonValue::String(s.to_string()))
+                        .collect(),
+                ),
+            ),
+        ]),
+        Resolver::Addition(left, right) => obj(vec![
+            op_tag("add"),
+            ("left", emit_resolver(left)),
+            ("right", emit_resolver(right)),
+        ]),
+        Resolver::Subtraction(left, right) => obj(vec![
+            op_tag("sub"),
+            ("left", emit_resolver(left)),
+            ("right", emit_resolver(right)),
+        ]),
+        Resolver::Multiplication(left, right) => obj(vec![
+            op_tag("mul"),
+            ("left", emit_resolver(left)),
+            ("right", emit_resolver(right)),
+        ]),
+        Resolver::Division(left, right) => obj(vec![
+            op_tag("div"),
+            ("left", emit_resolver(left)),
+            ("right", emit_resolver(right)),
         ]),
-        Resolver::Addition(left, right) => obj(vec![op_tag("add"), ("left", emit_resolver(left)), ("right", emit_resolver(right))]),
-        Resolver::Subtraction(left, right) => obj(vec![op_tag("sub"), ("left", emit_resolver(left)), ("right", emit_resolver(right))]),
-        Resolver::Multiplication(left, right) => obj(vec![op_tag("mul"), ("left", emit_resolver(left)), ("right", emit_resolver(right))]),
-        Resolver::Division(left, right) => obj(vec![op_tag("div"), ("left", emit_resolver(left)), ("right", emit_resolver(right))]),
         Resolver::SignTest { operator, receiver } => obj(vec![
             op_tag("sign_test"),
             ("cmp", emit_comparison(operator)),
             ("receiver", emit_resolver(receiver)),
         ]),
-        Resolver::Empty(receiver) => obj(vec![op_tag("empty"), ("receiver", emit_resolver(receiver))]),
+        Resolver::Empty(receiver) => {
+            obj(vec![op_tag("empty"), ("receiver", emit_resolver(receiver))])
+        }
         Resolver::ToS(receiver) => obj(vec![op_tag("to_s"), ("receiver", emit_resolver(receiver))]),
         Resolver::Modulo { receiver, divisor } => obj(vec![
             op_tag("modulo"),
             ("receiver", emit_resolver(receiver)),
             ("divisor", emit_resolver(divisor)),
         ]),
-        Resolver::Size(receiver) => obj(vec![op_tag("size"), ("receiver", emit_resolver(receiver))]),
-        Resolver::MatchesRegex { receiver, pattern, flags } => obj(vec![
+        Resolver::Size(receiver) => {
+            obj(vec![op_tag("size"), ("receiver", emit_resolver(receiver))])
+        }
+        Resolver::MatchesRegex {
+            receiver,
+            pattern,
+            flags,
+        } => obj(vec![
             op_tag("matches_regex"),
             ("receiver", emit_resolver(receiver)),
             ("pattern", JsonValue::String(pattern.clone())),
             ("flags", JsonValue::String(flags.clone())),
         ]),
-        Resolver::Presence { receiver, negated } => {
-            obj(vec![op_tag("presence"), ("receiver", emit_resolver(receiver)), ("negated", JsonValue::Bool(*negated))])
-        }
-        Resolver::Assignment { receiver, negated } => {
-            obj(vec![op_tag("assignment"), ("receiver", emit_resolver(receiver)), ("negated", JsonValue::Bool(*negated))])
-        }
-        Resolver::Split { receiver, separator } => {
-            obj(vec![op_tag("split"), ("receiver", emit_resolver(receiver)), ("separator", JsonValue::String(separator.clone()))])
-        }
-        Resolver::Strip { receiver, side } => {
-            obj(vec![op_tag("strip"), ("receiver", emit_resolver(receiver)), ("side", JsonValue::String((*side).to_string()))])
-        }
-        Resolver::StartsWith { receiver, substring } => {
-            obj(vec![op_tag("starts_with"), ("receiver", emit_resolver(receiver)), ("substring", JsonValue::String(substring.clone()))])
+        Resolver::Presence { receiver, negated } => obj(vec![
+            op_tag("presence"),
+            ("receiver", emit_resolver(receiver)),
+            ("negated", JsonValue::Bool(*negated)),
+        ]),
+        Resolver::Assignment { receiver, negated } => obj(vec![
+            op_tag("assignment"),
+            ("receiver", emit_resolver(receiver)),
+            ("negated", JsonValue::Bool(*negated)),
+        ]),
+        Resolver::Split {
+            receiver,
+            separator,
+        } => obj(vec![
+            op_tag("split"),
+            ("receiver", emit_resolver(receiver)),
+            ("separator", JsonValue::String(separator.clone())),
+        ]),
+        Resolver::Strip { receiver, side } => obj(vec![
+            op_tag("strip"),
+            ("receiver", emit_resolver(receiver)),
+            ("side", JsonValue::String((*side).to_string())),
+        ]),
+        Resolver::StartsWith {
+            receiver,
+            substring,
+        } => obj(vec![
+            op_tag("starts_with"),
+            ("receiver", emit_resolver(receiver)),
+            ("substring", JsonValue::String(substring.clone())),
+        ]),
+        Resolver::EndsWith {
+            receiver,
+            substring,
+        } => obj(vec![
+            op_tag("ends_with"),
+            ("receiver", emit_resolver(receiver)),
+            ("substring", JsonValue::String(substring.clone())),
+        ]),
+        Resolver::First(receiver) => {
+            obj(vec![op_tag("first"), ("receiver", emit_resolver(receiver))])
         }
-        Resolver::EndsWith { receiver, substring } => {
-            obj(vec![op_tag("ends_with"), ("receiver", emit_resolver(receiver)), ("substring", JsonValue::String(substring.clone()))])
+        Resolver::Last(receiver) => {
+            obj(vec![op_tag("last"), ("receiver", emit_resolver(receiver))])
         }
-        Resolver::First(receiver) => obj(vec![op_tag("first"), ("receiver", emit_resolver(receiver))]),
-        Resolver::Last(receiver) => obj(vec![op_tag("last"), ("receiver", emit_resolver(receiver))]),
-        Resolver::BlockPredicate { mode, receiver, param, predicate } => obj(vec![
+        Resolver::BlockPredicate {
+            mode,
+            receiver,
+            param,
+            predicate,
+        } => obj(vec![
             op_tag("block_predicate"),
             ("mode", JsonValue::String(mode.json_name().to_string())),
             ("receiver", emit_resolver(receiver)),
             ("param", JsonValue::String(param.clone())),
             ("predicate", emit_bool(predicate)),
         ]),
-        Resolver::Find { receiver, param, predicate, path } => obj(vec![
+        Resolver::Find {
+            receiver,
+            param,
+            predicate,
+            path,
+        } => obj(vec![
             op_tag("find"),
             ("receiver", emit_resolver(receiver)),
             ("param", JsonValue::String(param.clone())),
             ("predicate", emit_bool(predicate)),
-            ("path", JsonValue::Array(path.iter().map(|s| JsonValue::String(s.clone())).collect())),
+            (
+                "path",
+                JsonValue::Array(path.iter().map(|s| JsonValue::String(s.clone())).collect()),
+            ),
         ]),
         // The haystack case is intercepted in `emit_include`.
         Resolver::ArrayLiteral(elements) => obj(vec![
             op_tag("array"),
-            ("elements", JsonValue::Array(elements.iter().map(emit_resolver).collect())),
+            (
+                "elements",
+                JsonValue::Array(elements.iter().map(emit_resolver).collect()),
+            ),
         ]),
     }
 }

data/rust/parser/src/expr/evaluator.rs

@@ -5,11 +5,18 @@ use super::{top_level_index, Operator, OPERATORS};
 
 #[derive(Debug, Clone)]
 pub enum Evaluator {
-    Or(Box<Evaluator>, Box<Evaluator>),
-    And(Box<Evaluator>, Box<Evaluator>),
-    Not(Box<Evaluator>),
-    Compare { operator: Operator, left: Resolver, right: Resolver },
-    Include { haystack: Resolver, needle: Resolver },
+    Or(Box<Self>, Box<Self>),
+    And(Box<Self>, Box<Self>),
+    Not(Box<Self>),
+    Compare {
+        operator: Operator,
+        left: Resolver,
+        right: Resolver,
+    },
+    Include {
+        haystack: Resolver,
+        needle: Resolver,
+    },
     Resolve(Resolver),
 }
 
@@ -32,12 +39,19 @@ pub fn parse(expr: &str) -> Evaluator {
     }
 
     if let Some((haystack, needle)) = match_include(&expr) {
-        return Evaluator::Include { haystack: resolver::parse(haystack), needle: resolver::parse(needle) };
+        return Evaluator::Include {
+            haystack: resolver::parse(haystack),
+            needle: resolver::parse(needle),
+        };
     }
 
-    for op in OPERATORS.iter() {
+    for op in &OPERATORS {
         if let Some((left, right)) = split_comparison(&expr, op.symbol) {
-            return Evaluator::Compare { operator: *op, left: resolver::parse(left), right: resolver::parse(right) };
+            return Evaluator::Compare {
+                operator: *op,
+                left: resolver::parse(left),
+                right: resolver::parse(right),
+            };
         }
     }
 
@@ -57,7 +71,11 @@ fn split_comparison<'a>(expr: &'a str, operator: &str) -> Option<(&'a str, &'a s
 fn part_of_longer(expr: &str, index: usize, operator: &str) -> bool {
     let bytes = expr.as_bytes();
     let after = bytes.get(index + operator.len()).copied();
-    let before = if index > 0 { bytes.get(index - 1).copied() } else { None };
+    let before = if index > 0 {
+        bytes.get(index - 1).copied()
+    } else {
+        None
+    };
 
     if after == Some(b'=') && !operator.ends_with('=') {
         return true;

data/rust/parser/src/expr/mod.rs

@@ -6,7 +6,7 @@ pub mod resolver;
 
 /// A comparison operator. Order in `OPERATORS` matters: the first match wins,
 /// so `>=` and `<=` must precede `>` and `<`.
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Operator {
     pub symbol: &'static str,
     pub compares_less_than: bool,
@@ -15,20 +15,59 @@ pub struct Operator {
 }
 
 pub const OPERATORS: [Operator; 6] = [
-    Operator { symbol: ">=", compares_less_than: true, compares_equal: false, negated: true },
-    Operator { symbol: "<=", compares_less_than: true, compares_equal: true, negated: false },
-    Operator { symbol: "<", compares_less_than: true, compares_equal: false, negated: false },
-    Operator { symbol: ">", compares_less_than: true, compares_equal: true, negated: true },
-    Operator { symbol: "==", compares_less_than: false, compares_equal: true, negated: false },
-    Operator { symbol: "!=", compares_less_than: false, compares_equal: true, negated: true },
+    Operator {
+        symbol: ">=",
+        compares_less_than: true,
+        compares_equal: false,
+        negated: true,
+    },
+    Operator {
+        symbol: "<=",
+        compares_less_than: true,
+        compares_equal: true,
+        negated: false,
+    },
+    Operator {
+        symbol: "<",
+        compares_less_than: true,
+        compares_equal: false,
+        negated: false,
+    },
+    Operator {
+        symbol: ">",
+        compares_less_than: true,
+        compares_equal: true,
+        negated: true,
+    },
+    Operator {
+        symbol: "==",
+        compares_less_than: false,
+        compares_equal: true,
+        negated: false,
+    },
+    Operator {
+        symbol: "!=",
+        compares_less_than: false,
+        compares_equal: true,
+        negated: true,
+    },
 ];
 
 pub fn find_operator(symbol: &str) -> Operator {
-    *OPERATORS.iter().find(|op| op.symbol == symbol).unwrap_or_else(|| panic!("no such comparison operator {symbol:?}"))
+    // reason: callers pass the symbol literals `OPERATORS` declares, never input text.
+    #[allow(clippy::panic)]
+    *OPERATORS
+        .iter()
+        .find(|op| op.symbol == symbol)
+        .unwrap_or_else(|| panic!("no such comparison operator {symbol:?}"))
 }
 
 /// Index of the first top-level (outside quotes and brackets) `operator` that `accept` allows.
-pub fn top_level_index(expr: &str, operator: &str, accept: impl Fn(usize) -> bool) -> Option<usize> {
+pub fn top_level_index(
+    expr: &str,
+    operator: &str,
+    accept: impl Fn(usize) -> bool,
+) -> Option<usize> {
     let bytes = expr.as_bytes();
     let op_bytes = operator.as_bytes();
     let mut depth: i32 = 0;
@@ -48,10 +87,12 @@ pub fn top_level_index(expr: &str, operator: &str, accept: impl Fn(usize) -> boo
             depth += 1;
         } else if ch == b')' || ch == b'}' {
             depth -= 1;
-        } else if depth == 0 && index + op_bytes.len() <= bytes.len() && &bytes[index..index + op_bytes.len()] == op_bytes {
-            if accept(index) {
-                return Some(index);
-            }
+        } else if depth == 0
+            && index + op_bytes.len() <= bytes.len()
+            && &bytes[index..index + op_bytes.len()] == op_bytes
+            && accept(index)
+        {
+            return Some(index);
         }
         index += 1;
     }