Struct TermEnv 

pub struct TermEnv {
    pub terms: Vec<Term>,
    pub term_map: StableMap<Sym, TermId>,
    pub rules: Vec<Rule>,
    pub rule_map: StableMap<Sym, RuleId>,
    pub converters: StableMap<(TypeId, TypeId), TermId>,
    pub expand_internal_extractors: bool,
}

The term environment.

This is sort of a typed and reorganized AST that more directly reflects ISLE semantics than the input ISLE source code (where as the AST is the opposite).

Fields

terms: Vec<Term>

Arena of interned terms defined in this ISLE program.

This is indexed by TermId.

term_map: StableMap<Sym, TermId>

A map from am interned Term’s name to its TermId.

rules: Vec<Rule>

Arena of interned rules defined in this ISLE program.

This is indexed by RuleId.

rule_map: StableMap<Sym, RuleId>

A map from an interned Rule’s name to its RuleId.

converters: StableMap<(TypeId, TypeId), TermId>

Map from (inner_ty, outer_ty) pairs to term IDs, giving the defined implicit type-converter terms we can try to use to fit types together.

expand_internal_extractors: bool

Flag for whether to expand internal extractors in the translation from the AST to sema.

Implementations

impl TermEnv

pub fn from_ast( tyenv: &mut TypeEnv, defs: &[Def], expand_internal_extractors: bool, ) -> Result<TermEnv, Vec<Error>>

Construct the term environment from the AST and the type environment.

pub fn get_term_by_name(&self, tyenv: &TypeEnv, sym: &Ident) -> Option<TermId>

Lookup term by name.

pub fn get_rule_by_name(&self, tyenv: &TypeEnv, sym: &Ident) -> Option<RuleId>

Lookup rule by name.

pub fn get_variant_term( &self, tyenv: &TypeEnv, ty: TypeId, variant: VariantId, ) -> TermId

Lookup the term corresponding to the given enum variant.

Trait Implementations

impl Clone for TermEnv

fn clone(&self) -> TermEnv

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TermEnv

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

Formats the value using the given formatter.