Struct Expression 

pub struct Expression {
    pub text: String,
    pub operands: Vec<String>,
    pub line: usize,
}

Represents a computed expression for availability analysis.

An expression is a binary operation like a + b that can be tracked to detect Common Subexpression Elimination (CSE) opportunities.

CAP-AE-01: Equality and Hashing

Critical: Equality and hashing are based on text only, not line. This allows expressions with the same normalized text to be considered equal regardless of where they appear in the code.

Example

let expr1 = Expression::new("a + b", vec!["a", "b"], 1);
let expr2 = Expression::new("a + b", vec!["a", "b"], 100);

// Same text means equal, even with different lines
assert_eq!(expr1, expr2);

// Can be used in HashSet (only one entry)
let mut set = HashSet::new();
set.insert(expr1);
set.insert(expr2);
assert_eq!(set.len(), 1);

Fields

text: String

Normalized expression string (e.g., “a + b”). This is the canonical form after applying normalization rules.

operands: Vec<String>

Variables used in this expression (sorted alphabetically). Used for kill detection - if any operand is redefined, the expression is killed.

line: usize

Source line where this expression first appears. Note: This field is NOT used in equality or hashing (CAP-AE-01).

Implementations

impl Expression

pub fn new( text: impl Into<String>, operands: Vec<impl Into<String>>, line: usize, ) -> Self

Create a new Expression with the given components.

Arguments

• text - The normalized expression text
• operands - Variables used in the expression (will be sorted)
• line - Source line where expression appears

Example

let expr = Expression::new("a + b", vec!["a", "b"], 5);
assert_eq!(expr.text, "a + b");
assert_eq!(expr.operands, vec!["a", "b"]);
assert_eq!(expr.line, 5);

pub fn is_killed_by(&self, var: &str) -> bool

Check if redefining the given variable kills this expression.

An expression is killed when any of its operands is redefined. This is the foundation of the “kill” set in dataflow analysis.

Arguments

• var - The variable being redefined

Returns

true if this expression uses var and would be killed by its redefinition.

Example

let expr = Expression::new("a + b", vec!["a", "b"], 1);
assert!(expr.is_killed_by("a"));  // Uses 'a'
assert!(expr.is_killed_by("b"));  // Uses 'b'
assert!(!expr.is_killed_by("c")); // Doesn't use 'c'

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expression

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Expression

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Expression

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Expression

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Expression