Struct Module 

pub struct Module {

    pub span: SourceSpan,
    pub name: ModuleId,
    pub ty: ModuleType,
    pub imports: BTreeMap<ModuleId, Import>,
    pub constants: BTreeMap<Identifier, Constant>,
    pub evaluators: BTreeMap<Identifier, EvaluatorFunction>,
    pub functions: BTreeMap<Identifier, Function>,
    pub periodic_columns: BTreeMap<Identifier, PeriodicColumn>,
    pub public_inputs: BTreeMap<Identifier, PublicInput>,
    pub trace_columns: Vec<TraceSegment>,
    pub buses: BTreeMap<Identifier, Bus>,
    pub boundary_constraints: Option<Span<Vec<Statement>>>,
    pub integrity_constraints: Option<Span<Vec<Statement>>>,
}

This represents the parsed contents of a single AirScript module

When parsing successfully produces a Module, it is guaranteed that:

• Fields which are only allowed in root modules are empty/unset in library modules
• Fields which must be present in root modules are guaranteed to be present in a root module
• It is guaranteed that at least one boundary constraint and one integrity constraint are present in a root module
• No duplicate module-level declarations were present
• All globally-visible declarations are unique

However, most validation is not run at this stage, but rather later when producing a Program. In particular, variable declarations are not checked, and imports are only partially validated here, in that we check for obviously overlapping imports, but cannot fully validate them until later. Likewise we do not validate constraints, look for invalid variable usages, etc.

Fields

span: SourceSpan

name: ModuleId

ty: ModuleType

imports: BTreeMap<ModuleId, Import>

constants: BTreeMap<Identifier, Constant>

evaluators: BTreeMap<Identifier, EvaluatorFunction>

functions: BTreeMap<Identifier, Function>

periodic_columns: BTreeMap<Identifier, PeriodicColumn>

public_inputs: BTreeMap<Identifier, PublicInput>

trace_columns: Vec<TraceSegment>

buses: BTreeMap<Identifier, Bus>

boundary_constraints: Option<Span<Vec<Statement>>>

integrity_constraints: Option<Span<Vec<Statement>>>

Implementations

impl Module

pub fn new(ty: ModuleType, span: SourceSpan, name: ModuleId) -> Self

Constructs an empty module of the specified type, with the given span and name.

SAFETY

Similar to Program::new, this function simply constructs an empty Module, and so it does not uphold any guarantees described in it’s documentation. It is up to the caller to guarantee that they construct a valid module that upholds those guarantees, otherwise it is expected that compilation will panic at some point down the line.

pub fn from_declarations( diagnostics: &DiagnosticsHandler, ty: ModuleType, span: SourceSpan, name: Identifier, declarations: Vec<Declaration>, ) -> Result<Self, SemanticAnalysisError>

Constructs a module of the specified type, with the given span and name, using the provided declarations.

The resulting module has had some initial semantic analysis performed as described in the module docs. It is expected that this module will be added to a Library and used to construct a Program before it is considered fully validated.

pub fn is_root(&self) -> bool

pub fn is_library(&self) -> bool

pub fn exports(&self) -> impl Iterator<Item = Export<'_>> + '_

Traverse all of the items exported from this module

pub fn get(&self, id: &Identifier) -> Option<Export<'_>>

Get the export with the given identifier, if it can be found

Trait Implementations

impl Debug for Module

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

Formats the value using the given formatter.

impl Parse for Module

type Parser = AnyModuleParser

The concrete type of the parser implementation

type Error = ParseError

The concrete type of errors which are produced by the parser

type Config = ()

The concrete type representing the parser configuration.

type Token = Result<(SourceIndex, Token, SourceIndex), ParseError>

The concrete type of the lexical token consumed by the parser

fn root_file_error(source: Error, path: PathBuf) -> Self::Error

Constructs an instance of Self::Error when a [std:::io::Error] is raised

fn parse<S>( parser: &Parser, diagnostics: &DiagnosticsHandler, source: S, ) -> Result<Self, Self::Error>

where S: Source,

Parses a [T] from the given Source.

fn parse_tokens<S: IntoIterator<Item = Result<(SourceIndex, Token, SourceIndex), ParseError>>>( diagnostics: &DiagnosticsHandler, codemap: Arc<CodeMap>, tokens: S, ) -> Result<Self, Self::Error>

Parses a [T] from the given token stream.

impl PartialEq for Module

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 Module

fn span(&self) -> SourceSpan

impl Eq for Module