hecks 3.14.0 → 4.0.0

data/rust/src/kernel/expression_operators/mod.rs

@@ -6,18 +6,18 @@
 // uses — grouped by the `category` field Evaluator::PROJECTION already
 // partitions comparison operators by (evaluator.rb).
 
-pub mod logical;
-pub mod membership;
-pub mod comparison;
 pub mod arithmetic;
-pub mod sign_test;
-pub mod sized;
-pub mod to_string;
+pub mod comparison;
 pub mod enumeration;
+pub mod logical;
+pub mod membership;
 pub mod pattern_match;
+pub mod positional;
 pub mod presence;
+pub mod sign_test;
+pub mod sized;
 pub mod text;
-pub mod positional;
+pub mod to_string;
 
 /// One variant per real expression-operator category the Ruby
 /// grammar admits, in the order Grammar.admitted_operators's own `category` field declares them. Every match
@@ -47,22 +47,35 @@ impl OperatorCategory {
     /// variant names — `hecks measure_kernel_coverage`'s own existence
     /// check reads this, so the file-name spelling here is the ONE
     /// place that ever needs to change if a name is renamed.
-    pub fn module_name(&self) -> &'static str {
+    pub const fn module_name(&self) -> &'static str {
         match self {
-            OperatorCategory::Logical => "logical",
-            OperatorCategory::Membership => "membership",
-            OperatorCategory::Comparison => "comparison",
-            OperatorCategory::Arithmetic => "arithmetic",
-            OperatorCategory::SignTest => "sign_test",
-            OperatorCategory::Sized => "sized",
-            OperatorCategory::ToString => "to_string",
-            OperatorCategory::Enumeration => "enumeration",
-            OperatorCategory::PatternMatch => "pattern_match",
-            OperatorCategory::Presence => "presence",
-            OperatorCategory::Text => "text",
-            OperatorCategory::Positional => "positional",
+            Self::Logical => "logical",
+            Self::Membership => "membership",
+            Self::Comparison => "comparison",
+            Self::Arithmetic => "arithmetic",
+            Self::SignTest => "sign_test",
+            Self::Sized => "sized",
+            Self::ToString => "to_string",
+            Self::Enumeration => "enumeration",
+            Self::PatternMatch => "pattern_match",
+            Self::Presence => "presence",
+            Self::Text => "text",
+            Self::Positional => "positional",
         }
     }
 
-    pub const ALL: &'static [OperatorCategory] = &[OperatorCategory::Logical, OperatorCategory::Membership, OperatorCategory::Comparison, OperatorCategory::Arithmetic, OperatorCategory::SignTest, OperatorCategory::Sized, OperatorCategory::ToString, OperatorCategory::Enumeration, OperatorCategory::PatternMatch, OperatorCategory::Presence, OperatorCategory::Text, OperatorCategory::Positional];
+    pub const ALL: &'static [Self] = &[
+        Self::Logical,
+        Self::Membership,
+        Self::Comparison,
+        Self::Arithmetic,
+        Self::SignTest,
+        Self::Sized,
+        Self::ToString,
+        Self::Enumeration,
+        Self::PatternMatch,
+        Self::Presence,
+        Self::Text,
+        Self::Positional,
+    ];
 }

data/rust/src/kernel/expression_operators/pattern_match.rs

@@ -6,8 +6,15 @@ use crate::kernel::Refusal;
 use regex::RegexBuilder;
 
 pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
-    let Expr::MatchesRegex { receiver, pattern, flags } = expr else {
-        return Err(Refusal::TypeMismatch(format!("pattern_match::interpret called with a non-match? node {expr:?} — a router bug")));
+    let Expr::MatchesRegex {
+        receiver,
+        pattern,
+        flags,
+    } = expr
+    else {
+        return Err(Refusal::TypeMismatch(format!(
+            "pattern_match::interpret called with a non-match? node {expr:?} — a router bug"
+        )));
     };
 
     let text = coerce_text(&eval(receiver, ctx)?)?;
@@ -32,7 +39,9 @@ fn coerce_text(v: &Value) -> Result<String, Refusal> {
         Value::Int(i) => Ok(i.to_string()),
         Value::Float(f) => Ok(f.to_string()),
         Value::Nil => Ok(String::new()),
-        Value::Bool(_) | Value::List(_) | Value::Array(_) => Err(eval_error(format!("match? expects a scalar, got {v:?}"))),
+        Value::Bool(_) | Value::List(_) | Value::Array(_) => {
+            Err(eval_error(format!("match? expects a scalar, got {v:?}")))
+        }
     }
 }
 
@@ -41,21 +50,40 @@ mod tests {
     use super::*;
 
     fn matches(receiver: Expr, pattern: &str, flags: &str) -> Value {
-        let expr = Expr::MatchesRegex { receiver: Box::new(receiver), pattern: pattern.to_string(), flags: flags.to_string() };
-        let ctx = EvalContext { args: &crate::kernel::expr::NoFields, instance: &crate::kernel::expr::NoFields };
+        let expr = Expr::MatchesRegex {
+            receiver: Box::new(receiver),
+            pattern: pattern.to_string(),
+            flags: flags.to_string(),
+        };
+        let ctx = EvalContext {
+            args: &crate::kernel::expr::NoFields,
+            instance: &crate::kernel::expr::NoFields,
+        };
         eval(&expr, &ctx).expect("evaluates")
     }
 
     #[test]
     fn matches_a_simple_anchored_pattern() {
-        assert_eq!(matches(Expr::Str("12345".to_string()), r"\A\d{5}\z", ""), Value::Bool(true));
-        assert_eq!(matches(Expr::Str("1234".to_string()), r"\A\d{5}\z", ""), Value::Bool(false));
+        assert_eq!(
+            matches(Expr::Str("12345".to_string()), r"\A\d{5}\z", ""),
+            Value::Bool(true)
+        );
+        assert_eq!(
+            matches(Expr::Str("1234".to_string()), r"\A\d{5}\z", ""),
+            Value::Bool(false)
+        );
     }
 
     #[test]
     fn the_i_flag_ignores_case() {
-        assert_eq!(matches(Expr::Str("HELLO".to_string()), "hello", ""), Value::Bool(false));
-        assert_eq!(matches(Expr::Str("HELLO".to_string()), "hello", "i"), Value::Bool(true));
+        assert_eq!(
+            matches(Expr::Str("HELLO".to_string()), "hello", ""),
+            Value::Bool(false)
+        );
+        assert_eq!(
+            matches(Expr::Str("HELLO".to_string()), "hello", "i"),
+            Value::Bool(true)
+        );
     }
 
     #[test]
@@ -66,8 +94,15 @@ mod tests {
 
     #[test]
     fn an_invalid_pattern_refuses_cleanly() {
-        let expr = Expr::MatchesRegex { receiver: Box::new(Expr::Str("x".to_string())), pattern: "(".to_string(), flags: String::new() };
-        let ctx = EvalContext { args: &crate::kernel::expr::NoFields, instance: &crate::kernel::expr::NoFields };
+        let expr = Expr::MatchesRegex {
+            receiver: Box::new(Expr::Str("x".to_string())),
+            pattern: "(".to_string(),
+            flags: String::new(),
+        };
+        let ctx = EvalContext {
+            args: &crate::kernel::expr::NoFields,
+            instance: &crate::kernel::expr::NoFields,
+        };
         assert!(eval(&expr, &ctx).is_err());
     }
 }

data/rust/src/kernel/expression_operators/positional.rs

@@ -1,30 +1,41 @@
 //! Interprets `.first` and `.last` over an Array value or a list-typed field lookup.
 
-use crate::kernel::expr::{eval_error, interpret as eval, lookup_items, EvalContext, Expr, Field, Value};
+use crate::kernel::expr::{
+    eval_error, interpret as eval, lookup_items, EvalContext, Expr, Field, Value,
+};
 use crate::kernel::Refusal;
 
 pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
     let (op, receiver, take_first) = match expr {
         Expr::First(receiver) => ("first", receiver, true),
         Expr::Last(receiver) => ("last", receiver, false),
-        _ => return Err(Refusal::TypeMismatch(format!("positional::interpret called with a non-positional node {expr:?} — a router bug"))),
+        _ => {
+            return Err(Refusal::TypeMismatch(format!(
+                "positional::interpret called with a non-positional node {expr:?} — a router bug"
+            )))
+        }
     };
 
     match receiver.as_ref() {
         Expr::Lookup(path) => {
             // `Value::List` carries only a length, so read the elements directly.
             let items = lookup_items(path, ctx, op)?;
-            field_value(if take_first { items.into_iter().next() } else { items.into_iter().last() }, op)
+            field_value(
+                if take_first {
+                    items.into_iter().next()
+                } else {
+                    items.into_iter().last()
+                },
+                op,
+            )
         }
         other => match eval(other, ctx)? {
-            Value::Array(mut elements) => {
-                Ok(if take_first {
-                    elements.into_iter().next()
-                } else {
-                    elements.pop()
-                }
-                .unwrap_or(Value::Nil))
+            Value::Array(mut elements) => Ok(if take_first {
+                elements.into_iter().next()
+            } else {
+                elements.pop()
             }
+            .unwrap_or(Value::Nil)),
             v => Err(eval_error(format!("{op} expects a list, got {v:?}"))),
         },
     }
@@ -36,7 +47,9 @@ fn field_value(item: Option<Field<'_>>, op: &str) -> Result<Value, Refusal> {
     match item {
         None => Ok(Value::Nil),
         Some(Field::Value(v)) => Ok(v),
-        Some(Field::Nested(_)) => Err(eval_error(format!("{op} on a list of objects is not generated yet — only scalar-element lists are"))),
+        Some(Field::Nested(_)) => Err(eval_error(format!(
+            "{op} on a list of objects is not generated yet — only scalar-element lists are"
+        ))),
     }
 }
 
@@ -45,30 +58,48 @@ mod tests {
     use super::*;
     use crate::kernel::expr::{Fielded, NoFields};
 
-    fn run(expr: Expr, instance: &dyn Fielded) -> Value {
-        let ctx = EvalContext { args: &NoFields, instance };
-        eval(&expr, &ctx).expect("evaluates")
+    fn run(expr: &Expr, instance: &dyn Fielded) -> Value {
+        let ctx = EvalContext {
+            args: &NoFields,
+            instance,
+        };
+        eval(expr, &ctx).expect("evaluates")
     }
 
     #[test]
     fn first_and_last_over_an_array_literal() {
         let arr = Expr::Array(vec![Expr::Int(1), Expr::Int(2), Expr::Int(3)]);
-        assert_eq!(run(Expr::First(Box::new(arr.clone())), &NoFields), Value::Int(1));
-        assert_eq!(run(Expr::Last(Box::new(arr)), &NoFields), Value::Int(3));
+        assert_eq!(
+            run(&Expr::First(Box::new(arr.clone())), &NoFields),
+            Value::Int(1)
+        );
+        assert_eq!(run(&Expr::Last(Box::new(arr)), &NoFields), Value::Int(3));
     }
 
     #[test]
     fn first_and_last_over_an_empty_array_literal_answer_nil() {
         let arr = Expr::Array(vec![]);
-        assert_eq!(run(Expr::First(Box::new(arr.clone())), &NoFields), Value::Nil);
-        assert_eq!(run(Expr::Last(Box::new(arr)), &NoFields), Value::Nil);
+        assert_eq!(
+            run(&Expr::First(Box::new(arr.clone())), &NoFields),
+            Value::Nil
+        );
+        assert_eq!(run(&Expr::Last(Box::new(arr)), &NoFields), Value::Nil);
     }
 
     #[test]
     fn first_and_last_compose_with_split() {
-        let phrase = Expr::Split { receiver: Box::new(Expr::Str("a::b::c".to_string())), separator: "::".to_string() };
-        assert_eq!(run(Expr::Last(Box::new(phrase.clone())), &NoFields), Value::Str("c".to_string()));
-        assert_eq!(run(Expr::First(Box::new(phrase)), &NoFields), Value::Str("a".to_string()));
+        let phrase = Expr::Split {
+            receiver: Box::new(Expr::Str("a::b::c".to_string())),
+            separator: "::".to_string(),
+        };
+        assert_eq!(
+            run(&Expr::Last(Box::new(phrase.clone())), &NoFields),
+            Value::Str("c".to_string())
+        );
+        assert_eq!(
+            run(&Expr::First(Box::new(phrase)), &NoFields),
+            Value::Str("a".to_string())
+        );
     }
 
     struct Tags {
@@ -76,24 +107,40 @@ mod tests {
     }
     impl Fielded for Tags {
         fn field(&self, name: &str) -> Option<Field<'_>> {
-            (name == "tags").then(|| Field::Value(Value::List(self.values.len())))
+            (name == "tags").then_some(Field::Value(Value::List(self.values.len())))
         }
         fn items(&self, name: &str) -> Option<Vec<Field<'_>>> {
-            (name == "tags").then(|| self.values.iter().map(|t| Field::Value(Value::Str(t.clone()))).collect())
+            (name == "tags").then(|| {
+                self.values
+                    .iter()
+                    .map(|t| Field::Value(Value::Str(t.clone())))
+                    .collect()
+            })
         }
     }
 
     #[test]
     fn first_over_a_real_scalar_element_field() {
-        let tags = Tags { values: vec!["a".to_string(), "b".to_string()] };
-        assert_eq!(run(Expr::First(Box::new(Expr::Lookup("tags"))), &tags), Value::Str("a".to_string()));
-        assert_eq!(run(Expr::Last(Box::new(Expr::Lookup("tags"))), &tags), Value::Str("b".to_string()));
+        let tags = Tags {
+            values: vec!["a".to_string(), "b".to_string()],
+        };
+        assert_eq!(
+            run(&Expr::First(Box::new(Expr::Lookup("tags"))), &tags),
+            Value::Str("a".to_string())
+        );
+        assert_eq!(
+            run(&Expr::Last(Box::new(Expr::Lookup("tags"))), &tags),
+            Value::Str("b".to_string())
+        );
     }
 
     #[test]
     fn first_over_an_empty_field_answers_nil() {
         let tags = Tags { values: vec![] };
-        assert_eq!(run(Expr::First(Box::new(Expr::Lookup("tags"))), &tags), Value::Nil);
+        assert_eq!(
+            run(&Expr::First(Box::new(Expr::Lookup("tags"))), &tags),
+            Value::Nil
+        );
     }
 
     struct Leg {
@@ -109,7 +156,7 @@ mod tests {
     }
     impl Fielded for Itinerary {
         fn field(&self, name: &str) -> Option<Field<'_>> {
-            (name == "legs").then(|| Field::Value(Value::List(self.legs.len())))
+            (name == "legs").then_some(Field::Value(Value::List(self.legs.len())))
         }
         fn items(&self, name: &str) -> Option<Vec<Field<'_>>> {
             (name == "legs").then(|| self.legs.iter().map(|leg| Field::Nested(leg)).collect())
@@ -118,8 +165,15 @@ mod tests {
 
     #[test]
     fn first_over_a_list_of_objects_refuses_by_name_instead_of_misrepresenting_one() {
-        let itinerary = Itinerary { legs: vec![Leg { origin: "SFO".to_string() }] };
-        let ctx = EvalContext { args: &NoFields, instance: &itinerary };
+        let itinerary = Itinerary {
+            legs: vec![Leg {
+                origin: "SFO".to_string(),
+            }],
+        };
+        let ctx = EvalContext {
+            args: &NoFields,
+            instance: &itinerary,
+        };
         let err = eval(&Expr::First(Box::new(Expr::Lookup("legs"))), &ctx).unwrap_err();
         assert!(format!("{err:?}").contains("not generated yet"), "{err:?}");
     }

data/rust/src/kernel/expression_operators/presence.rs

@@ -6,7 +6,9 @@ use crate::kernel::Refusal;
 
 pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
     let Expr::Presence { receiver, negated } = expr else {
-        return Err(Refusal::TypeMismatch(format!("presence::interpret called with a non-presence node {expr:?} — a router bug")));
+        return Err(Refusal::TypeMismatch(format!(
+            "presence::interpret called with a non-presence node {expr:?} — a router bug"
+        )));
     };
 
     let v = eval(receiver, ctx)?;
@@ -32,7 +34,7 @@ pub fn interpret_assignment(expr: &Expr, ctx: &EvalContext) -> Result<Value, Ref
 }
 
 /// Rails-style blankness: nil, false, and an empty Str or Array.
-fn blank(v: &Value) -> bool {
+const fn blank(v: &Value) -> bool {
     match v {
         Value::Nil | Value::Bool(false) => true,
         Value::Str(s) => s.is_empty(),
@@ -47,8 +49,14 @@ mod tests {
     use crate::kernel::expr::NoFields;
 
     fn present(receiver: Expr, negated: bool) -> Value {
-        let expr = Expr::Presence { receiver: Box::new(receiver), negated };
-        let ctx = EvalContext { args: &NoFields, instance: &NoFields };
+        let expr = Expr::Presence {
+            receiver: Box::new(receiver),
+            negated,
+        };
+        let ctx = EvalContext {
+            args: &NoFields,
+            instance: &NoFields,
+        };
         eval(&expr, &ctx).expect("evaluates")
     }
 
@@ -61,7 +69,10 @@ mod tests {
     #[test]
     fn an_empty_string_is_blank_but_a_nonempty_one_is_present() {
         assert_eq!(present(Expr::Str(String::new()), false), Value::Bool(false));
-        assert_eq!(present(Expr::Str("x".to_string()), false), Value::Bool(true));
+        assert_eq!(
+            present(Expr::Str("x".to_string()), false),
+            Value::Bool(true)
+        );
     }
 
     #[test]
@@ -72,18 +83,30 @@ mod tests {
     #[test]
     fn blank_negates_present() {
         assert_eq!(present(Expr::Nil, true), Value::Bool(true));
-        assert_eq!(present(Expr::Str("x".to_string()), true), Value::Bool(false));
+        assert_eq!(
+            present(Expr::Str("x".to_string()), true),
+            Value::Bool(false)
+        );
     }
 
     #[test]
     fn an_empty_array_literal_is_blank() {
         assert_eq!(present(Expr::Array(vec![]), false), Value::Bool(false));
-        assert_eq!(present(Expr::Array(vec![Expr::Int(1)]), false), Value::Bool(true));
+        assert_eq!(
+            present(Expr::Array(vec![Expr::Int(1)]), false),
+            Value::Bool(true)
+        );
     }
 
     fn set(receiver: Expr, negated: bool) -> Value {
-        let expr = Expr::Assignment { receiver: Box::new(receiver), negated };
-        let ctx = EvalContext { args: &NoFields, instance: &NoFields };
+        let expr = Expr::Assignment {
+            receiver: Box::new(receiver),
+            negated,
+        };
+        let ctx = EvalContext {
+            args: &NoFields,
+            instance: &NoFields,
+        };
         eval(&expr, &ctx).expect("evaluates")
     }
 
@@ -120,15 +143,31 @@ mod tests {
     }
 
     fn set_on(draft: &Draft, negated: bool) -> Value {
-        let expr = Expr::Assignment { receiver: Box::new(Expr::Lookup("body")), negated };
-        eval(&expr, &EvalContext { args: &NoFields, instance: draft }).expect("evaluates")
+        let expr = Expr::Assignment {
+            receiver: Box::new(Expr::Lookup("body")),
+            negated,
+        };
+        eval(
+            &expr,
+            &EvalContext {
+                args: &NoFields,
+                instance: draft,
+            },
+        )
+        .expect("evaluates")
     }
 
     #[test]
     fn a_nested_object_field_is_set_and_an_absent_one_is_not() {
-        assert_eq!(set_on(&Draft { body: Some(Body) }, false), Value::Bool(true));
+        assert_eq!(
+            set_on(&Draft { body: Some(Body) }, false),
+            Value::Bool(true)
+        );
         assert_eq!(set_on(&Draft { body: None }, false), Value::Bool(false));
-        assert_eq!(set_on(&Draft { body: Some(Body) }, true), Value::Bool(false));
+        assert_eq!(
+            set_on(&Draft { body: Some(Body) }, true),
+            Value::Bool(false)
+        );
     }
 
     #[test]

data/rust/src/kernel/expression_operators/sign_test.rs

@@ -6,7 +6,9 @@ use crate::kernel::Refusal;
 
 pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
     let Expr::SignTest { op, receiver } = expr else {
-        return Err(Refusal::TypeMismatch(format!("sign_test::interpret called with a non-sign-test node {expr:?} — a router bug")));
+        return Err(Refusal::TypeMismatch(format!(
+            "sign_test::interpret called with a non-sign-test node {expr:?} — a router bug"
+        )));
     };
 
     // Comparing against 0 through `comparison::apply` treats int and float alike.

data/rust/src/kernel/expression_operators/sized.rs

@@ -6,30 +6,46 @@ use crate::kernel::Refusal;
 
 pub fn empty(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
     let Expr::Empty(receiver) = expr else {
-        return Err(Refusal::TypeMismatch(format!("sized::empty called with a non-empty? node {expr:?} — a router bug")));
+        return Err(Refusal::TypeMismatch(format!(
+            "sized::empty called with a non-empty? node {expr:?} — a router bug"
+        )));
     };
 
     let v = eval(receiver, ctx)?;
     // Every `Value` variant is named so a new one forces a decision here.
     match v {
-        Value::Str(_) => Ok(Value::Bool(scalar::is_empty(&v).expect("Str always answers is_empty"))),
-        Value::List(_) => Ok(Value::Bool(list::is_empty(&v).expect("List always answers is_empty"))),
+        Value::Str(_) => Ok(Value::Bool(scalar::is_empty(&v).ok_or_else(|| {
+            eval_error("router bug: Str always answers is_empty".to_string())
+        })?)),
+        Value::List(_) => Ok(Value::Bool(list::is_empty(&v).ok_or_else(|| {
+            eval_error("router bug: List always answers is_empty".to_string())
+        })?)),
         // A materialised Array answers from its own length.
         Value::Array(ref elements) => Ok(Value::Bool(elements.is_empty())),
-        Value::Int(_) | Value::Float(_) | Value::Bool(_) | Value::Nil => Err(eval_error(format!("empty? expects a list or string, got {v:?}"))),
+        Value::Int(_) | Value::Float(_) | Value::Bool(_) | Value::Nil => Err(eval_error(format!(
+            "empty? expects a list or string, got {v:?}"
+        ))),
     }
 }
 
 pub fn size(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
     let Expr::Size(receiver) = expr else {
-        return Err(Refusal::TypeMismatch(format!("sized::size called with a non-size node {expr:?} — a router bug")));
+        return Err(Refusal::TypeMismatch(format!(
+            "sized::size called with a non-size node {expr:?} — a router bug"
+        )));
     };
 
     let v = eval(receiver, ctx)?;
     match v {
-        Value::Str(_) => Ok(Value::Int(scalar::size(&v).expect("Str always answers size"))),
-        Value::List(_) => Ok(Value::Int(list::size(&v).expect("List always answers size"))),
+        Value::Str(_) => Ok(Value::Int(scalar::size(&v).ok_or_else(|| {
+            eval_error("router bug: Str always answers size".to_string())
+        })?)),
+        Value::List(_) => Ok(Value::Int(list::size(&v).ok_or_else(|| {
+            eval_error("router bug: List always answers size".to_string())
+        })?)),
         Value::Array(ref elements) => Ok(Value::Int(elements.len() as i64)),
-        Value::Int(_) | Value::Float(_) | Value::Bool(_) | Value::Nil => Err(eval_error(format!("size expects a list or string, got {v:?}"))),
+        Value::Int(_) | Value::Float(_) | Value::Bool(_) | Value::Nil => Err(eval_error(format!(
+            "size expects a list or string, got {v:?}"
+        ))),
     }
 }