Enum SemanticAnalysisError 

pub enum SemanticAnalysisError {
    MissingRoot,
    MissingConstraints,
    MissingPublicInputs,
    MissingModule(ModuleId),
    RootSectionInLibrary(SourceSpan),
    RootImport(SourceSpan),
    NameConflict(SourceSpan),
    ImportUndefined(ModuleId),
    ImportSelf(SourceSpan),
    ImportConflict {
        item: Identifier,
        prev: SourceSpan,
    },
    ImportFailed(SourceSpan),
    InvalidExpr(InvalidExprError),
    InvalidType(InvalidTypeError),
    Invalid,
}

Represents the various module validation errors we might encounter during semantic analysis.

Variants

MissingRoot

MissingConstraints

MissingPublicInputs

MissingModule(ModuleId)

RootSectionInLibrary(SourceSpan)

RootImport(SourceSpan)

NameConflict(SourceSpan)

ImportUndefined(ModuleId)

ImportSelf(SourceSpan)

ImportConflict

Fields

item: Identifier

prev: SourceSpan

ImportFailed(SourceSpan)

InvalidExpr(InvalidExprError)

InvalidType(InvalidTypeError)

Invalid

Trait Implementations

impl Clone for SemanticAnalysisError

fn clone(&self) -> SemanticAnalysisError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SemanticAnalysisError

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

Formats the value using the given formatter.

impl Display for SemanticAnalysisError

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

Formats the value using the given formatter.

impl Error for SemanticAnalysisError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<InvalidExprError> for SemanticAnalysisError

fn from(source: InvalidExprError) -> Self

Converts to this type from the input type.

impl From<InvalidTypeError> for SemanticAnalysisError

fn from(source: InvalidTypeError) -> Self

Converts to this type from the input type.

impl From<SemanticAnalysisError> for ParseError

fn from(source: SemanticAnalysisError) -> Self

Converts to this type from the input type.

impl PartialEq for SemanticAnalysisError

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 ToDiagnostic for SemanticAnalysisError

fn to_diagnostic(self) -> Diagnostic

impl VisitMut<SemanticAnalysisError> for ConstantPropagation<'_>

fn visit_mut_scalar_expr( &mut self, expr: &mut ScalarExpr, ) -> ControlFlow<SemanticAnalysisError>

Fold constant expressions

fn visit_mut_statement( &mut self, _: &mut Statement, ) -> ControlFlow<SemanticAnalysisError>

It should not be possible to reach this, as we handle statements at the block level

fn visit_mut_expr( &mut self, expr: &mut Expr, ) -> ControlFlow<SemanticAnalysisError>

fn visit_mut_statement_block( &mut self, statements: &mut Vec<Statement>, ) -> ControlFlow<SemanticAnalysisError>

fn visit_mut_module(&mut self, module: &mut Module) -> ControlFlow<T>

fn visit_mut_import(&mut self, expr: &mut Import) -> ControlFlow<T>

fn visit_mut_constant(&mut self, expr: &mut Constant) -> ControlFlow<T>

fn visit_mut_evaluator_function( &mut self, expr: &mut EvaluatorFunction, ) -> ControlFlow<T>

fn visit_mut_function(&mut self, expr: &mut Function) -> ControlFlow<T>

fn visit_mut_bus(&mut self, expr: &mut Bus) -> ControlFlow<T>

fn visit_mut_periodic_column( &mut self, expr: &mut PeriodicColumn, ) -> ControlFlow<T>

fn visit_mut_public_input(&mut self, expr: &mut PublicInput) -> ControlFlow<T>

fn visit_mut_trace_segment(&mut self, expr: &mut TraceSegment) -> ControlFlow<T>

fn visit_mut_trace_binding(&mut self, expr: &mut TraceBinding) -> ControlFlow<T>

fn visit_mut_evaluator_trace_segment( &mut self, expr: &mut TraceSegment, ) -> ControlFlow<T>

fn visit_mut_evaluator_trace_binding( &mut self, expr: &mut TraceBinding, ) -> ControlFlow<T>

fn visit_mut_let(&mut self, expr: &mut Let) -> ControlFlow<T>

fn visit_mut_boundary_constraints( &mut self, exprs: &mut Vec<Statement>, ) -> ControlFlow<T>

fn visit_mut_enforce(&mut self, expr: &mut ScalarExpr) -> ControlFlow<T>

fn visit_mut_enforce_if( &mut self, expr: &mut ScalarExpr, selector: &mut ScalarExpr, ) -> ControlFlow<T>

fn visit_mut_enforce_all( &mut self, expr: &mut ListComprehension, ) -> ControlFlow<T>

fn visit_mut_bus_enforce( &mut self, expr: &mut ListComprehension, ) -> ControlFlow<T>

fn visit_mut_integrity_constraints( &mut self, exprs: &mut Vec<Statement>, ) -> ControlFlow<T>

fn visit_mut_binary_expr(&mut self, expr: &mut BinaryExpr) -> ControlFlow<T>

fn visit_mut_list_comprehension( &mut self, expr: &mut ListComprehension, ) -> ControlFlow<T>

fn visit_mut_call(&mut self, expr: &mut Call) -> ControlFlow<T>

fn visit_mut_bus_operation(&mut self, expr: &mut BusOperation) -> ControlFlow<T>

fn visit_mut_range_bound(&mut self, expr: &mut RangeBound) -> ControlFlow<T>

fn visit_mut_access_type(&mut self, expr: &mut AccessType) -> ControlFlow<T>

fn visit_mut_const_symbol_access( &mut self, expr: &mut ConstSymbolAccess, ) -> ControlFlow<T>

fn visit_mut_bounded_symbol_access( &mut self, expr: &mut BoundedSymbolAccess, ) -> ControlFlow<T>

fn visit_mut_symbol_access(&mut self, expr: &mut SymbolAccess) -> ControlFlow<T>

fn visit_mut_resolvable_identifier( &mut self, expr: &mut ResolvableIdentifier, ) -> ControlFlow<T>

fn visit_mut_identifier(&mut self, expr: &mut Identifier) -> ControlFlow<T>

fn visit_mut_typed_identifier( &mut self, expr: &mut (Identifier, Type), ) -> ControlFlow<T>

impl Eq for SemanticAnalysisError