hecks 3.14.0 → 5.0.0

data/rust/src/kernel/expr.rs

@@ -19,20 +19,20 @@ pub enum Value {
     /// above. Produced by an array literal or `.split`; never used for
     /// `.include?`'s haystack (`expr_emitter.rb`'s `emit_include` rewrites
     /// that shape at codegen time instead).
-    Array(Vec<Value>),
+    Array(Vec<Self>),
 }
 
 impl Value {
     /// Ruby's `Evaluator.truthy?`: false only for `Nil`/`Bool(false)`.
-    pub fn truthy(&self) -> bool {
-        !matches!(self, Value::Nil | Value::Bool(false))
+    pub const fn truthy(&self) -> bool {
+        !matches!(self, Self::Nil | Self::Bool(false))
     }
 
     /// The text of a `Str`, else `None`; a generated `SetProjectedField` arm narrows a
     /// projected scalar to its field's type with one of the `into_*` readers.
     pub fn into_string(self) -> Option<String> {
         match self {
-            Value::Str(s) => Some(s),
+            Self::Str(s) => Some(s),
             _ => None,
         }
     }
@@ -40,7 +40,7 @@ impl Value {
     /// The integer of an `Int`, else `None`.
     pub fn into_i64(self) -> Option<i64> {
         match self {
-            Value::Int(n) => Some(n),
+            Self::Int(n) => Some(n),
             _ => None,
         }
     }
@@ -48,7 +48,7 @@ impl Value {
     /// The float of a `Float`, else `None`.
     pub fn into_f64(self) -> Option<f64> {
         match self {
-            Value::Float(f) => Some(f),
+            Self::Float(f) => Some(f),
             _ => None,
         }
     }
@@ -56,7 +56,7 @@ impl Value {
     /// The boolean of a `Bool`, else `None`.
     pub fn into_bool(self) -> Option<bool> {
         match self {
-            Value::Bool(b) => Some(b),
+            Self::Bool(b) => Some(b),
             _ => None,
         }
     }
@@ -94,7 +94,7 @@ pub struct Bound<'a> {
     pub rest: &'a dyn Fielded,
 }
 
-impl<'a> Fielded for Bound<'a> {
+impl Fielded for Bound<'_> {
     fn field(&self, name: &str) -> Option<Field<'_>> {
         if name == self.name {
             return Some(match &self.value {
@@ -130,7 +130,7 @@ pub struct WithOld<'a> {
     pub old: &'a dyn Fielded,
 }
 
-impl<'a> Fielded for WithOld<'a> {
+impl Fielded for WithOld<'_> {
     fn field(&self, name: &str) -> Option<Field<'_>> {
         if name == "old" {
             return Some(Field::Nested(self.old));
@@ -154,7 +154,7 @@ pub struct StateFirst<'a> {
     pub settled: &'a dyn Fielded,
 }
 
-impl<'a> Fielded for StateFirst<'a> {
+impl Fielded for StateFirst<'_> {
     fn field(&self, name: &str) -> Option<Field<'_>> {
         if self.settled.field(name).is_some() {
             return None;
@@ -178,7 +178,7 @@ pub struct WithParent<'a> {
     pub parent: &'a dyn Fielded,
 }
 
-impl<'a> Fielded for WithParent<'a> {
+impl Fielded for WithParent<'_> {
     fn field(&self, name: &str) -> Option<Field<'_>> {
         if name == "parent" {
             return Some(Field::Nested(self.parent));
@@ -210,11 +210,11 @@ pub enum BlockMode {
 impl BlockMode {
     /// The operator's own spelling, for the "expects a list" wording
     /// Ruby renders from `"#{node.mode}?"`.
-    pub fn ruby_name(&self) -> &'static str {
+    pub const fn ruby_name(&self) -> &'static str {
         match self {
-            BlockMode::All => "all?",
-            BlockMode::Any => "any?",
-            BlockMode::None => "none?",
+            Self::All => "all?",
+            Self::Any => "any?",
+            Self::None => "none?",
         }
     }
 }
@@ -225,61 +225,106 @@ impl BlockMode {
 #[derive(Debug, Clone)]
 #[allow(dead_code)]
 pub enum Expr {
-    Or(Box<Expr>, Box<Expr>),
-    And(Box<Expr>, Box<Expr>),
-    Not(Box<Expr>),
-    Compare { op: Comparison, left: Box<Expr>, right: Box<Expr> },
-    Include { haystack: Box<Expr>, needle: Box<Expr> },
+    Or(Box<Self>, Box<Self>),
+    And(Box<Self>, Box<Self>),
+    Not(Box<Self>),
+    Compare {
+        op: Comparison,
+        left: Box<Self>,
+        right: Box<Self>,
+    },
+    Include {
+        haystack: Box<Self>,
+        needle: Box<Self>,
+    },
     Int(i64),
     Float(f64),
     Str(String),
     Bool(bool),
     Nil,
-    Add(Box<Expr>, Box<Expr>),
-    Sub(Box<Expr>, Box<Expr>),
-    Mul(Box<Expr>, Box<Expr>),
+    Add(Box<Self>, Box<Self>),
+    Sub(Box<Self>, Box<Self>),
+    Mul(Box<Self>, Box<Self>),
     /// Floor division on integers; a zero divisor is an evaluation fault.
-    Div(Box<Expr>, Box<Expr>),
-    SignTest { op: Comparison, receiver: Box<Expr> },
-    Empty(Box<Expr>),
-    ToS(Box<Expr>),
-    Modulo { receiver: Box<Expr>, divisor: Box<Expr> },
-    Size(Box<Expr>),
+    Div(Box<Self>, Box<Self>),
+    SignTest {
+        op: Comparison,
+        receiver: Box<Self>,
+    },
+    Empty(Box<Self>),
+    ToS(Box<Self>),
+    Modulo {
+        receiver: Box<Self>,
+        divisor: Box<Self>,
+    },
+    Size(Box<Self>),
     Lookup(&'static str),
     /// `receiver.any?`/`.all?`/`.none? { |param| predicate }` —
     /// evaluated once per element with `param` bound (see `Bound`).
-    BlockPredicate { mode: BlockMode, receiver: Box<Expr>, param: &'static str, predicate: Box<Expr> },
+    BlockPredicate {
+        mode: BlockMode,
+        receiver: Box<Self>,
+        param: &'static str,
+        predicate: Box<Self>,
+    },
     /// `receiver.find { |param| predicate }.a.b` — first accepted
     /// element, projected through `path`, or nil when nothing matches.
-    Find { receiver: Box<Expr>, param: &'static str, predicate: Box<Expr>, path: &'static [&'static str] },
+    Find {
+        receiver: Box<Self>,
+        param: &'static str,
+        predicate: Box<Self>,
+        path: &'static [&'static str],
+    },
     /// `[a, b, c]` — a leaf like `Int`/`Str`/`Nil` above, not an
     /// operator, so `interpret` handles it directly, not via
     /// `dispatch_operator`.
-    Array(Vec<Expr>),
+    Array(Vec<Self>),
     /// `receiver.match?(/pattern/flags)` — `pattern` is a real
     /// Ruby-Regexp source, taken as-is between the slashes.
-    MatchesRegex { receiver: Box<Expr>, pattern: String, flags: String },
+    MatchesRegex {
+        receiver: Box<Self>,
+        pattern: String,
+        flags: String,
+    },
     /// `receiver.present?` / `.blank?` — one node for the pair,
     /// `negated` distinguishing them (`.blank?` is `.present?` negated).
-    Presence { receiver: Box<Expr>, negated: bool },
+    Presence {
+        receiver: Box<Self>,
+        negated: bool,
+    },
     /// `receiver.set?` / `.unset?` — narrower than `Presence`: only
     /// `!receiver.is_nil()`. An assigned-but-empty value is `.set?`,
     /// unlike `Presence`'s Rails-standard emptiness reading.
-    Assignment { receiver: Box<Expr>, negated: bool },
+    Assignment {
+        receiver: Box<Self>,
+        negated: bool,
+    },
     /// `receiver.split("SEP")` — `Resolver::Split`. Produces a real
     /// `Value::Array`, not `Value::List` — see that variant's own header.
-    Split { receiver: Box<Expr>, separator: String },
+    Split {
+        receiver: Box<Self>,
+        separator: String,
+    },
     /// `receiver.strip` / `.lstrip` / `.rstrip` — `Resolver::Strip`. Trims Ruby's own whitespace
     /// set (see `StripSide::trim`), not Unicode spaces.
-    Strip { receiver: Box<Expr>, side: StripSide },
+    Strip {
+        receiver: Box<Self>,
+        side: StripSide,
+    },
     /// `receiver.start_with?("prefix")` — `Resolver::StartsWith`.
-    StartsWith { receiver: Box<Expr>, substring: String },
+    StartsWith {
+        receiver: Box<Self>,
+        substring: String,
+    },
     /// `receiver.end_with?("suffix")` — `Resolver::EndsWith`.
-    EndsWith { receiver: Box<Expr>, substring: String },
+    EndsWith {
+        receiver: Box<Self>,
+        substring: String,
+    },
     /// `receiver.first` — `Resolver::First`.
-    First(Box<Expr>),
+    First(Box<Self>),
     /// `receiver.last` — `Resolver::Last`.
-    Last(Box<Expr>),
+    Last(Box<Self>),
 }
 
 /// Which ends of a string `Expr::Strip` trims: `.strip` both, `.lstrip` the start, `.rstrip` the end.
@@ -295,11 +340,12 @@ impl StripSide {
     /// return and space, never a Unicode space. Rust's own `trim` would also drop U+00A0 and the
     /// rest, so the set is spelled out.
     pub fn trim(self, text: &str) -> String {
-        let is_stripped = |c: char| matches!(c, '\0' | '\t' | '\n' | '\u{b}' | '\u{c}' | '\r' | ' ');
+        let is_stripped =
+            |c: char| matches!(c, '\0' | '\t' | '\n' | '\u{b}' | '\u{c}' | '\r' | ' ');
         match self {
-            StripSide::Both => text.trim_matches(is_stripped),
-            StripSide::Left => text.trim_start_matches(is_stripped),
-            StripSide::Right => text.trim_end_matches(is_stripped),
+            Self::Both => text.trim_matches(is_stripped),
+            Self::Left => text.trim_start_matches(is_stripped),
+            Self::Right => text.trim_end_matches(is_stripped),
         }
         .to_string()
     }
@@ -315,7 +361,7 @@ pub struct EvalContext<'a> {
 /// Leaves (literals, `Lookup`) have no `OperatorCategory`, so they're
 /// handled directly; everything else routes through `dispatch_operator`.
 pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
-    use Expr::*;
+    use Expr::{Array, Bool, Float, Int, Lookup, Nil, Str};
     match expr {
         Int(v) => Ok(Value::Int(*v)),
         Float(v) => Ok(Value::Float(*v)),
@@ -323,7 +369,12 @@ pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
         Bool(v) => Ok(Value::Bool(*v)),
         Nil => Ok(Value::Nil),
         Lookup(path) => lookup(path, ctx),
-        Array(elements) => Ok(Value::Array(elements.iter().map(|e| interpret(e, ctx)).collect::<Result<Vec<_>, _>>()?)),
+        Array(elements) => Ok(Value::Array(
+            elements
+                .iter()
+                .map(|e| interpret(e, ctx))
+                .collect::<Result<Vec<_>, _>>()?,
+        )),
         _ => dispatch_operator(category_of(expr), expr, ctx),
     }
 }
@@ -332,7 +383,11 @@ pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
 /// hand-written association `interpret` never calls for a leaf, hence
 /// the `unreachable!` there rather than a wrong category.
 fn category_of(expr: &Expr) -> OperatorCategory {
-    use Expr::*;
+    use Expr::{
+        Add, And, Array, Assignment, BlockPredicate, Bool, Compare, Div, Empty, EndsWith, Find,
+        First, Float, Include, Int, Last, Lookup, MatchesRegex, Modulo, Mul, Nil, Not, Or,
+        Presence, SignTest, Size, Split, StartsWith, Str, Strip, Sub, ToS,
+    };
     match expr {
         Or(..) | And(..) | Not(..) => OperatorCategory::Logical,
         Include { .. } => OperatorCategory::Membership,
@@ -356,22 +411,35 @@ fn category_of(expr: &Expr) -> OperatorCategory {
 /// removing a variant (hecks project_kernel_capabilities) stops this
 /// compiling until a matching arm exists. Never add one back — it would
 /// silently route a new category to the wrong operator file.
-fn dispatch_operator(category: OperatorCategory, expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
-    use expression_operators::*;
+fn dispatch_operator(
+    category: OperatorCategory,
+    expr: &Expr,
+    ctx: &EvalContext,
+) -> Result<Value, Refusal> {
+    use expression_operators::{
+        arithmetic, comparison, enumeration, logical, membership, pattern_match, positional,
+        presence, sign_test, sized, text, to_string, OperatorCategory,
+    };
     match category {
         OperatorCategory::Logical => logical::interpret(expr, ctx),
         OperatorCategory::Membership => membership::interpret(expr, ctx),
         OperatorCategory::Comparison => comparison::interpret(expr, ctx),
         OperatorCategory::Arithmetic => match expr {
-            Expr::Add(..) | Expr::Sub(..) | Expr::Mul(..) | Expr::Div(..) => arithmetic::binary(expr, ctx),
+            Expr::Add(..) | Expr::Sub(..) | Expr::Mul(..) | Expr::Div(..) => {
+                arithmetic::binary(expr, ctx)
+            }
             Expr::Modulo { .. } => arithmetic::modulo(expr, ctx),
-            _ => Err(Refusal::TypeMismatch(format!("dispatch_operator(Arithmetic, ..) called with {expr:?} — a router bug"))),
+            _ => Err(Refusal::TypeMismatch(format!(
+                "dispatch_operator(Arithmetic, ..) called with {expr:?} — a router bug"
+            ))),
         },
         OperatorCategory::SignTest => sign_test::interpret(expr, ctx),
         OperatorCategory::Sized => match expr {
             Expr::Empty(..) => sized::empty(expr, ctx),
             Expr::Size(..) => sized::size(expr, ctx),
-            _ => Err(Refusal::TypeMismatch(format!("dispatch_operator(Sized, ..) called with {expr:?} — a router bug"))),
+            _ => Err(Refusal::TypeMismatch(format!(
+                "dispatch_operator(Sized, ..) called with {expr:?} — a router bug"
+            ))),
         },
         OperatorCategory::ToString => to_string::interpret(expr, ctx),
         OperatorCategory::Enumeration => enumeration::interpret(expr, ctx),
@@ -379,7 +447,9 @@ fn dispatch_operator(category: OperatorCategory, expr: &Expr, ctx: &EvalContext)
         OperatorCategory::Presence => match expr {
             Expr::Presence { .. } => presence::interpret(expr, ctx),
             Expr::Assignment { .. } => presence::interpret_assignment(expr, ctx),
-            _ => Err(Refusal::TypeMismatch(format!("dispatch_operator(Presence, ..) called with {expr:?} — a router bug"))),
+            _ => Err(Refusal::TypeMismatch(format!(
+                "dispatch_operator(Presence, ..) called with {expr:?} — a router bug"
+            ))),
         },
         OperatorCategory::Text => text::interpret(expr, ctx),
         OperatorCategory::Positional => positional::interpret(expr, ctx),
@@ -398,15 +468,19 @@ fn lookup(path: &str, ctx: &EvalContext) -> Result<Value, Refusal> {
 /// nested object, which `.set?` reads as present without needing it to be one value.
 pub(crate) fn lookup_field<'a>(path: &str, ctx: &EvalContext<'a>) -> Result<Field<'a>, Refusal> {
     let mut segments = path.split('.');
-    let head = segments.next().unwrap();
+    let head = segments.next().unwrap_or_default();
     let mut current = ctx
         .args
         .field(head)
         .or_else(|| ctx.instance.field(head))
-        .ok_or_else(|| eval_error(format!("cannot resolve {head:?} — no such attribute or argument")))?;
+        .ok_or_else(|| {
+            eval_error(format!(
+                "cannot resolve {head:?} — no such attribute or argument"
+            ))
+        })?;
 
     for seg in segments {
-        current = composite::step(current, seg, head)?;
+        current = composite::step(&current, seg, head)?;
     }
 
     Ok(current)
@@ -415,34 +489,54 @@ pub(crate) fn lookup_field<'a>(path: &str, ctx: &EvalContext<'a>) -> Result<Fiel
 /// The list-elements reading of a `Lookup` path — same head resolution
 /// as `lookup`, then `Fielded::items` on the last segment (a list is
 /// always the end of a path). `op` names the caller for error wording.
-pub(crate) fn lookup_items<'a>(path: &str, ctx: &EvalContext<'a>, op: &str) -> Result<Vec<Field<'a>>, Refusal> {
-    let segments: Vec<&str> = path.split('.').collect();
-    let (head, rest) = segments.split_first().unwrap();
+pub(crate) fn lookup_items<'a>(
+    path: &str,
+    ctx: &EvalContext<'a>,
+    op: &str,
+) -> Result<Vec<Field<'a>>, Refusal> {
+    let mut segments = path.split('.');
+    let head = segments.next().unwrap_or_default();
+    let rest: Vec<&str> = segments.collect();
 
-    if rest.is_empty() {
+    let Some((last, middle)) = rest.split_last() else {
         // args first when the key is present there, state second — a
         // non-list argument refuses rather than falling through to a
         // same-named instance list.
-        let side: &'a dyn Fielded = if ctx.args.field(head).is_some() { ctx.args } else { ctx.instance };
-        return side
-            .items(head)
-            .ok_or_else(|| eval_error(format!("{op} expects a list, got {}", describe_field(side.field(head)))));
-    }
+        let side: &'a dyn Fielded = if ctx.args.field(head).is_some() {
+            ctx.args
+        } else {
+            ctx.instance
+        };
+        return side.items(head).ok_or_else(|| {
+            eval_error(format!(
+                "{op} expects a list, got {}",
+                describe_field(side.field(head))
+            ))
+        });
+    };
 
-    let (last, middle) = rest.split_last().unwrap();
     let mut current = ctx
         .args
         .field(head)
         .or_else(|| ctx.instance.field(head))
-        .ok_or_else(|| eval_error(format!("cannot resolve {head:?} — no such attribute or argument")))?;
+        .ok_or_else(|| {
+            eval_error(format!(
+                "cannot resolve {head:?} — no such attribute or argument"
+            ))
+        })?;
     for seg in middle {
-        current = composite::step(current, seg, head)?;
+        current = composite::step(&current, seg, head)?;
     }
     match current {
-        Field::Nested(obj) => obj
-            .items(last)
-            .ok_or_else(|| eval_error(format!("{op} expects a list, got {}", describe_field(obj.field(last))))),
-        Field::Value(v) => Err(eval_error(format!("{path} — cannot look up {last:?} on scalar {v:?}"))),
+        Field::Nested(obj) => obj.items(last).ok_or_else(|| {
+            eval_error(format!(
+                "{op} expects a list, got {}",
+                describe_field(obj.field(last))
+            ))
+        }),
+        Field::Value(v) => Err(eval_error(format!(
+            "{path} — cannot look up {last:?} on scalar {v:?}"
+        ))),
     }
 }
 
@@ -454,7 +548,7 @@ fn describe_field(field: Option<Field<'_>>) -> String {
     }
 }
 
-pub(crate) fn eval_error(message: String) -> Refusal {
+pub(crate) const fn eval_error(message: String) -> Refusal {
     Refusal::Fault(message)
 }
 
@@ -473,10 +567,9 @@ mod lookup_tests {
         fn field(&self, name: &str) -> Option<Field<'_>> {
             match name {
                 "previous_sessions" => Some(Field::Value(Value::Bool(self.previous_sessions))),
-                "first_time" => Some(match self.first_time {
-                    Some(b) => Field::Value(Value::Bool(b)),
-                    None => Field::Value(Value::Nil),
-                }),
+                "first_time" => Some(Field::Value(
+                    self.first_time.map_or(Value::Nil, Value::Bool),
+                )),
                 _ => None,
             }
         }
@@ -484,7 +577,10 @@ mod lookup_tests {
 
     fn not_nil(field: &'static str, instance: &dyn Fielded) -> Value {
         let expr = Expr::Not(Box::new(Expr::Lookup(field)));
-        let ctx = EvalContext { args: &NoFields, instance };
+        let ctx = EvalContext {
+            args: &NoFields,
+            instance,
+        };
         interpret(&expr, &ctx).expect("evaluates without refusing")
     }
 
@@ -493,8 +589,14 @@ mod lookup_tests {
         // `!previous_sessions.nil?` — the live crash, `previous_sessions:
         // true`: `.nil?` is not a dedicated node in this grammar, so this
         // is really `Lookup("previous_sessions.nil?")` negated.
-        let attendee = Attendee { previous_sessions: true, first_time: None };
-        assert_eq!(not_nil("previous_sessions.nil?", &attendee), Value::Bool(true));
+        let attendee = Attendee {
+            previous_sessions: true,
+            first_time: None,
+        };
+        assert_eq!(
+            not_nil("previous_sessions.nil?", &attendee),
+            Value::Bool(true)
+        );
     }
 
     #[test]
@@ -502,8 +604,14 @@ mod lookup_tests {
         // The other half of the live crash: `false` is exactly as
         // present as `true` — `walk_path` never inspects the value,
         // only whether the head attribute resolved at all.
-        let attendee = Attendee { previous_sessions: false, first_time: None };
-        assert_eq!(not_nil("previous_sessions.nil?", &attendee), Value::Bool(true));
+        let attendee = Attendee {
+            previous_sessions: false,
+            first_time: None,
+        };
+        assert_eq!(
+            not_nil("previous_sessions.nil?", &attendee),
+            Value::Bool(true)
+        );
     }
 
     #[test]
@@ -511,7 +619,10 @@ mod lookup_tests {
         // Matches Ruby parity: `walk_path` breaks to `nil` off any
         // scalar before inspecting `.nil?`'s segment name, so `!x.nil?`
         // reads `true` for any head attribute that resolved, set or not.
-        let attendee = Attendee { previous_sessions: true, first_time: None };
+        let attendee = Attendee {
+            previous_sessions: true,
+            first_time: None,
+        };
         assert_eq!(not_nil("first_time.nil?", &attendee), Value::Bool(true));
     }
 
@@ -519,9 +630,15 @@ mod lookup_tests {
     fn a_genuinely_missing_head_attribute_still_refuses() {
         // An undeclared head attribute is still a codegen bug, not a
         // legitimate absent value — see `lookup`'s own doc comment.
-        let attendee = Attendee { previous_sessions: true, first_time: None };
+        let attendee = Attendee {
+            previous_sessions: true,
+            first_time: None,
+        };
         let expr = Expr::Not(Box::new(Expr::Lookup("not_a_real_attribute.nil?")));
-        let ctx = EvalContext { args: &NoFields, instance: &attendee };
+        let ctx = EvalContext {
+            args: &NoFields,
+            instance: &attendee,
+        };
         assert!(interpret(&expr, &ctx).is_err());
     }
 }