Struct moore_vhdl::term::TermContext

pub struct TermContext<'sbc, 'lazy: 'sbc, 'sb: 'lazy, 'ast: 'sb, 'ctx: 'sb> {
    pub ctx: &'sbc ScoreContext<'lazy, 'sb, 'ast, 'ctx>,
    pub scope: ScopeRef,
}

A context within which termification can occur.

Fields

ctx: &'sbc ScoreContext<'lazy, 'sb, 'ast, 'ctx>

The underlying scoreboard context.

scope: ScopeRef

The scope within which the terms will resolve their names.

Methods

impl<'sbc, 'lazy, 'sb, 'ast, 'ctx> TermContext<'sbc, 'lazy, 'sb, 'ast, 'ctx>

fn new(
    ctx: &'sbc ScoreContext<'lazy, 'sb, 'ast, 'ctx>,
    scope: ScopeRef
) -> TermContext<'sbc, 'lazy, 'sb, 'ast, 'ctx>

Create a new termification context.

fn fold(&self, term: Spanned<Term>) -> Spanned<Term>

Perform term folding.

This is a post-processing step that should be applied to all terms once they are constructed. Folding applies transformations to the terms, e.g. changing Ident(Type|Subtype) to TypeMark, or gobbling up subtype constraints where appropriate.

fn termify_subtype_ind(&self, subty: &'ast SubtypeInd) -> Result<Spanned<Term>>

Map an AST subtype indication to a term.

fn termify_expr(&self, ast: &'ast Expr) -> Result<Spanned<Term>>

Map an AST expression to a term.

fn termify_literal(&self, ast: Spanned<&'ast Literal>) -> Result<Spanned<Term>>

Map an AST literal to a term.

fn termify_compound_name(
    &self,
    ast: &'ast CompoundName
) -> Result<Spanned<Term>>

Map an AST compound name to a term.

fn termify_name(&self, name: Spanned<ResolvableName>) -> Result<Spanned<Term>>

Map a resolvable name to a term.

This function is the bottom of the pit. Names are resolved here and mapped to the corresponding term. Calling functions may then proceed to handle the term as they see fit, usually inspecting what exact kind the term is of.

fn termify_name_in_scope(
    &self,
    name: Spanned<ResolvableName>,
    scope: ScopeRef
) -> Result<Spanned<Term>>

Map a resolvable name to a term, resolving it within a scope.

fn termify_paren_elems(&self, elems: &'ast ParenElems) -> Result<Spanned<Term>>

Map multiple parenthesis elements to a term.

fn termify_latent_name(&self, name: LatentName<'ast>) -> Result<Spanned<Term>>

Map a latent name to a term.

fn term_to_expr(&self, term: Spanned<Term>) -> Result<ExprRef>

Map a term to an expression and schedule the necessary tasks.

fn term_to_expr_spanned(&self, term: Spanned<Term>) -> Result<Spanned<ExprRef>>

Same as term_to_expr, but the result is spanned.

fn term_to_expr_raw(&self, term: Spanned<Term>) -> Result<Expr>

Map a term to an expression.

fn term_to_type_mark(&self, term: Spanned<Term>) -> Result<Spanned<TypeMarkRef>>

Map a term to a type mark.

fn fold_term_as_type(&self, term: Spanned<Term>) -> Result<Spanned<Term>>

Perform term folding expecting to yield a type.

This is a pre-processing step on terms. It is applied as soon as it is clear that a certain term should yield a type, e.g. when mapping to a subtype indication. This function performs certain precedence swaps and combines terms into higher level ones, e.g. Term::SubtypeInd.

fn term_to_subtype_ind(
    &self,
    term: Spanned<Term>
) -> Result<Spanned<SubtypeInd>>

Map a term to a subtype indication.

fn term_to_resolution_indication(
    &self,
    term: Spanned<Term>
) -> Result<Spanned<()>>

Map a term to a resolution indication.

fn term_to_constraint(&self, term: Spanned<Term>) -> Result<Spanned<Constraint>>

Map a term to a constraint.

fn term_to_array_constraint(
    &self,
    span: Span,
    terms: Vec<Spanned<Term>>,
    elem: Option<Spanned<Term>>
) -> Result<Spanned<ArrayConstraint>>

Map a term to an array constraint.

fn term_to_record_constraint(
    &self,
    span: Span,
    terms: Vec<Spanned<Term>>
) -> Result<Spanned<RecordConstraint>>

Map a term to a record constraint.

fn term_to_element_constraint(
    &self,
    term: Spanned<Term>
) -> Result<Spanned<ElementConstraint>>

Map a term to an element constraint.

fn term_to_discrete_range(
    &self,
    term: Spanned<Term>
) -> Result<Spanned<DiscreteRange>>

Map a term to a discrete range.

fn term_to_range(&self, term: Spanned<Term>) -> Result<Spanned<Range>>

Map a term to a range.

fn term_to_ident(&self, term: Spanned<Term>) -> Result<Spanned<Def>>

Map a term to a definition.

This works for terms that are actually identifiers.

fn term_to_label(&self, term: Spanned<Term>) -> Result<Spanned<StmtRef>>

Map a term to a label.

Returns the statement the label refers to.

fn term_to_signal(&self, term: Spanned<Term>) -> Result<Spanned<SignalRef>>

Map a term to a signal.

fn term_to_choice(&self, term: Spanned<Term>) -> Result<Spanned<Choice>>

Map a term to a choice.

See IEEE 1076-2008 section 9.3.3.1. A choice can be a simple expression, a discrete range, an identifier, or the keyword others.

fn term_to_aggregate(
    &self,
    term: Spanned<Term>
) -> Result<Spanned<AggregateRef>>

Map a term to an aggregate.

See IEEE 1076-2008 section 9.3.3.1.

fn term_to_assoc_list(&self, term: Spanned<Term>) -> Result<Spanned<AssocList>>

Map a term to an association list.

See IEEE 1076-2008 section 6.5.7.

fn term_to_assoc_actual(
    &self,
    term: Spanned<Term>
) -> Result<Spanned<AssocActual>>

Map a term to an association actual.

Trait Implementations

impl<'sbc, 'lazy, 'sb, 'ast, 'ctx> DiagEmitter for TermContext<'sbc, 'lazy, 'sb, 'ast, 'ctx>

fn emit(&self, diag: DiagBuilder2)

Emit a diagnostic message.