Struct moore_vhdl::defs::DefsContext

pub struct DefsContext<'sbc, 'lazy: 'sbc, 'sb: 'lazy, 'ast: 'sb, 'ctx: 'sb> { /* fields omitted */ }

A context to declare things in.

This context helps gather the definitions in a scope. It accepts definitions and keeps track of errors that occurred. Once done the context can be converted into the actual definitions, which fails in case of errors.

Implementations

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

pub fn new(
    ctx: &'sbc ScoreContext<'lazy, 'sb, 'ast, 'ctx>
) -> DefsContext<'sbc, 'lazy, 'sb, 'ast, 'ctx>

Create a new definition context.

pub fn finish(self) -> Result<Defs>

Consume the context and return the definitions that were made.

Returns an error if an error occurred during the earlier gathering of definitions.

pub fn emit(&mut self, diag: DiagBuilder2)

Emit a diagnostic message.

pub fn declare(&mut self, name: Spanned<ResolvableName>, def: Def)

Declare a name in the scope.

pub fn declare_primary_name(&mut self, name: &PrimaryName, def: Def)

Declare a primary name in the scope.

This converts the name to a ResolvableName and calls declare().

pub fn declare_pkg(&mut self, id: PkgDeclRef)

Handle package declarations.

pub fn declare_pkg_inst(&mut self, id: PkgInstRef)

Handle package instantiations.

pub fn declare_type(&mut self, id: TypeDeclRef)

Handle type declarations.

pub fn declare_subtype(&mut self, id: SubtypeDeclRef)

Handle subtype declarations.

pub fn declare_any_in_block(&mut self, id: DeclInBlockRef)

Handle any of the declarations that can appear in a block.

pub fn declare_any_in_pkg(&mut self, id: DeclInPkgRef)

Handle any of the declarations that can appear in a package.

pub fn declare_any_in_pkg_body(&mut self, id: DeclInPkgBodyRef)

Handle any of the declarations that can appear in a package.

pub fn declare_any_in_subprog(&mut self, id: DeclInSubprogRef)

Handle any of the declarations that can appear in a subprogram.

pub fn declare_any_in_process(&mut self, id: DeclInProcRef)

Handle any of the declarations that can appear in a process.

pub fn declare_const(&mut self, id: ConstDeclRef)

Handle a constant declaration.

pub fn declare_signal(&mut self, id: SignalDeclRef)

Handle a signal declaration.

pub fn declare_var(&mut self, id: VarDeclRef)

Handle a variable declaration.

pub fn declare_file(&mut self, id: FileDeclRef)

Handle a file declaration.

pub fn declare_alias(&mut self, id: AliasDeclRef)

Handle an alias declaration.

pub fn declare_comp(&mut self, id: CompDeclRef)

Handle a component declaration.

pub fn declare_attr(&mut self, id: AttrDeclRef)

Handle an attribute declaration.

pub fn declare_group_temp(&mut self, id: GroupTempRef)

Handle a group template declaration.

pub fn declare_group(&mut self, id: GroupDeclRef)

Handle a group declaration.

pub fn declare_subprog(&mut self, id: SubprogDeclRef)

Handle subprogram declarations.

pub fn declare_subprog_inst(&mut self, id: SubprogInstRef)

Handle subprogram instantiations.

pub fn declare_subprog_spec(&mut self, hir: &SubprogSpec)

Handle subprogram specifications.

Note that this does not declare the subprogram itself, but rather its parameters and generics.

pub fn declare_intf_objs(&mut self, ids: &[IntfObjRef])

Handle interface objects.

These are mainly subprogram parameters and entity ports.

pub fn declare_generics(&mut self, ids: &[GenericRef])

Handle generics.