Struct AbstractValue 

pub struct AbstractValue {
    pub type_: Option<String>,
    pub range_: Option<(Option<i64>, Option<i64>)>,
    pub nullable: Nullability,
    pub constant: Option<ConstantValue>,
}

Abstract representation of a variable’s value at a program point.

Tracks four dimensions:

• type_: Inferred type (str, int, list, etc.) or None if unknown
• range_: Value range [min, max] for numeric types, None for unbounded
• nullable: Whether the value can be null/None
• constant: If value is a known constant, the value itself

Range Representation

The range_ field uses Option<(Option<i64>, Option<i64>)>:

• None outer: No range information (unknown)
• Some((None, None)): Unbounded range (-inf, +inf)
• Some((Some(5), Some(5))): Exact value [5, 5]
• Some((Some(1), None)): Lower bound only [1, +inf)
• Some((None, Some(10))): Upper bound only (-inf, 10]

JSON Infinity Representation (TIGER-PASS2-5)

In JSON output:

• null in range array position = infinity (unbounded)
• Example: "range": [null, 10] means (-inf, 10]

TIGER-PASS1-11: Saturating Arithmetic

All arithmetic operations on ranges use saturating operations to prevent overflow. When overflow would occur, the bound is widened to infinity (None).

Fields

type_: Option<String>

Inferred type name (e.g., “int”, “str”) or None if unknown

range_: Option<(Option<i64>, Option<i64>)>

Value range [min, max] for numerics. None bounds mean infinity. For strings, tracks length.

nullable: Nullability

Nullability status

constant: Option<ConstantValue>

Known constant value (used for constant propagation)

Implementations

impl AbstractValue

pub fn top() -> Self

CAP-AI-04: Top of lattice - no information known (most permissive)

Returns an abstract value representing complete uncertainty:

• Unknown type
• Unknown range
• Maybe nullable
• No constant value

This is the default for variables with no information.

pub fn bottom() -> Self

CAP-AI-04: Bottom of lattice - contradiction (unreachable code)

Returns an abstract value representing impossibility. Used for unreachable code paths.

Represented as:

• Type = “”
• Range = (None, None) - representing contradiction
• Nullable = Never (contradicts Always)
• No constant

pub fn from_constant(value: ConstantValue) -> Self

CAP-AI-03: Create from known constant value

Creates an abstract value with precise information from a constant:

Constant Type	type_	range_	nullable	constant
Int(v)	“int”	[v, v]	Never	Some(Int(v))
Float(v)	“float”	None	Never	Some(Float(v))
String(s)	“str”	[len, len]	Never	Some(String(s))
Bool(v)	“bool”	[v as i64, v as i64]	Never	Some(Bool(v))
Null	“NoneType”	None	Always	None

TIGER-PASS2-8: TypeScript undefined vs null

TypeScript undefined is tracked separately from null:

• null -> type_ = “null”
• undefined -> type_ = “undefined”

Both have nullable = Always.

pub fn may_be_zero(&self) -> bool

CAP-AI-05: Check if value could be zero (for division check)

Returns true if the range includes zero, indicating potential division-by-zero if used as a divisor.

Logic

• Unknown range (None) -> true (conservative)
• Range [low, high] where low <= 0 <= high -> true
• Range [1, 10] -> false (excludes zero)
• Range [-10, -1] -> false (excludes zero)

pub fn may_be_null(&self) -> bool

CAP-AI-06: Check if value could be null/None

Returns true if the value might be null, indicating potential null dereference if used for attribute access.

Logic

• Never -> false (safe to dereference)
• Maybe -> true (might be null)
• Always -> true (definitely null)

pub fn is_constant(&self) -> bool

Check if this is a known constant value

Returns true if the constant field is set.

pub fn to_json_value(&self) -> Value

Convert to JSON-serializable format

JSON Format

{
  "type": "int",           // or null if unknown
  "range": [5, 5],         // [low, high], null = infinity
  "nullable": "never",     // "never" | "maybe" | "always"
  "constant": 5            // only if known constant
}

Trait Implementations

impl Clone for AbstractValue

fn clone(&self) -> AbstractValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AbstractValue

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

Formats the value using the given formatter.

impl Hash for AbstractValue

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 AbstractValue

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 Eq for AbstractValue