Struct SymbolAccess 

pub struct SymbolAccess {
    pub span: SourceSpan,
    pub name: ResolvableIdentifier,
    pub access_type: AccessType,
    pub offset: usize,
    pub ty: Option<Type>,
}

SymbolAccess represents access to a named item in the source code; one of the following:

• A global name associated with trace columns or public inputs
• A named constant
• A module-local name associated with periodic columns
• A evaluator/function parameter
• A let-bound variable

Fields

span: SourceSpan

name: ResolvableIdentifier

The symbol being accessed

access_type: AccessType

The type of access

offset: usize

Used when the accessing a trace column with ', indicates the offset from the current row in the trace. Defaults to zero.

NOTE: When accessed with an offset, trace columns are treated as scalar values, not as trace columns proper. What this means is that such an access cannot be used in a context where a trace column is expected, only where a scalar value is expected.

ty: Option<Type>

Used during name resolution/type checking to store the type associated with the value produced by the symbol access. If unset, it simply means that the type has not been checked/resolved.

Implementations

impl SymbolAccess

pub const fn new( span: SourceSpan, name: Identifier, access_type: AccessType, offset: usize, ) -> Self

pub fn access( &self, access_type: AccessType, ) -> Result<Self, InvalidAccessError>

Generates a new SymbolAccess that represents accessing this access, i.e. nesting accesses. For example, if called with AccessType::Index, and the current access type is Default, a new SymbolAccess is returned which has an access type of Index. However, if the current access type was Index, then the resulting SymbolAccess will have an access type of Matrix

It is expected that the type of this access has been resolved already, and this function will panic if that is not the case.

Trait Implementations

impl Clone for SymbolAccess

fn clone(&self) -> SymbolAccess

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SymbolAccess

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

Formats the value using the given formatter.

impl Display for SymbolAccess

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

Formats the value using the given formatter.

impl From<SymbolAccess> for Expr

fn from(expr: SymbolAccess) -> Self

Converts to this type from the input type.

impl PartialEq for SymbolAccess

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 Spanned for SymbolAccess

fn span(&self) -> SourceSpan

impl Eq for SymbolAccess