Struct Fact 

pub struct Fact {
    pub type_name: String,
    pub args: Option<Vec<String>>,
    pub call: Option<String>,
    pub awaited: bool,
    pub is_array: bool,
    pub nullable: bool,
    pub lambda: Option<LambdaSlot>,
}

One receiver fact: the declared type NAME plus that type’s top-level type-argument descriptors when it carried any. Two facts agree only when BOTH halves do, so Box<int> a and Box<string> a in sibling blocks conflict exactly like two different type names would.

Fields

type_name: String

The type name value.

args: Option<Vec<String>>

The args value.

call: Option<String>

When set, the name’s type is whatever the method of this name returns on the type type_name stands for, a lookup only the resolver can do. Part of the equality the table compares, so var x = A.Make() and var x = A.Build() in sibling blocks conflict exactly like two different type names would.

awaited: bool

true when this is a call fact (call.is_some()) built from an AWAITED invocation (var x = await Q.M()); meaningless – and always false – when call is None. Part of the equality the table compares, so var x = Q.M() and var x = await Q.M() in sibling blocks conflict exactly like two different callees would, rather than silently picking one awaited-ness for a name the source gives two.

is_array: bool

true when the declaration’s own type node was, at its TOP level, an array_type (Widget[]) – set ONLY by type_fact, false everywhere else (a call fact, a receiver-args unwrap, this/base’s own fact: none of those can be an array). base_type_identifier already collapses Widget[] to the same type_name/args shape a plain Widget field would carry (the element type’s own base identifier, no type-argument list), so this bit is the ONLY signal left that distinguishes “one Widget” from “an array of Widget” – needed by the lambda-parameter element-typing rule, which must tell Widget[] apart from Widget even though both facts otherwise read identically. Part of the equality the table compares.

nullable: bool

true when the declaration’s own type node was, at its TOP level, a nullable_type (Widget?) – set ONLY by type_fact, false everywhere else, mirroring is_array: a call fact, a receiver-args unwrap and this/base’s own fact are never nullable-annotated. base_type_identifier already unwraps Widget? to the same type_name a plain Widget field would carry, so this bit is the only signal left that a System.Nullable<T> sits between the declared name and the value – needed so the resolver can refuse a member the wrapper itself owns (.Value, .HasValue, .GetValueOrDefault) rather than binding T’s own same-named member. Part of the equality the table compares.

lambda: Option<LambdaSlot>

When set, the name is an untyped lambda parameter whose type is the corresponding delegate parameter of the callee this slot names – a lookup only the resolver can do; type_name is empty and call is None. Part of the equality the table compares, so two sibling lambdas binding the same parameter name to different callees conflict exactly like two different type names would.

Trait Implementations

impl Clone for Fact

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Eq for Fact

impl PartialEq for Fact

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Fact