Struct moore_svlog::GlobalContext

pub struct GlobalContext<'gcx> {
    pub sess: &'gcx Session,
    pub arena: &'gcx GlobalArenas<'gcx>,
    // some fields omitted
}

The central data structure of the compiler. It stores references to various arenas and tables that store the results of the various computations that have been performed.

Fields

sess: &'gcx Session

The global compiler session.

arena: &'gcx GlobalArenas<'gcx>

The arena that owns all references.

Methods

impl<'gcx> GlobalContext<'gcx>

pub fn new(sess: &'gcx Session, arena: &'gcx GlobalArenas<'gcx>) -> Self

Create a new global context.

pub fn add_root_nodes(&self, ast: impl Iterator<Item = &'gcx Root>)

Add root AST nodes to the context for processing.

Use the find_global_item function afterwards to look up the id of modules that were added.

pub fn find_module(&self, name: Name) -> Option<NodeId>

Find a module in the AST.

pub fn modules(&self) -> impl Iterator<Item = (Name, NodeId)>

Get an iterator over all modules in the AST.

pub fn find_package(&self, name: Name) -> Option<NodeId>

Find a package in the AST.

Trait Implementations

impl<'gcx> BaseContext<'gcx> for GlobalContext<'gcx>

fn gcx(&self) -> &GlobalContext<'gcx>

Get the global context.

fn sess(&self) -> &'gcx Session

Get the compiler session.

fn arena(&self) -> &'gcx GlobalArenas<'gcx>

Access the arena into which values are to be allocated.

fn tables(&self) -> &GlobalTables<'gcx>

Access the tables.

fn unimp<T: HasSpan + HasDesc, R>(&self, node: &T) -> Result<R>

Emit an internal compiler error that a node is not implemented.

fn unimp_msg<T: HasSpan + HasDesc, R>(
    &self,
    msg: impl Into<String>,
    node: &T
) -> Result<R>

Emit an internal compiler error and message that a node is not implemented. Same as [unimp], but the caller can provide a message prefix.

fn alloc_id(&self, span: Span) -> NodeId

Allocate a new node id.

fn span(&self, node_id: NodeId) -> Span

Return the diagnostic span associated with a ndoe id.

fn set_ast(&self, node_id: NodeId, ast: AstNode<'gcx>)

Associate an AST node with a node id.

fn map_ast(&self, ast: AstNode<'gcx>) -> NodeId

Allocate a node id for an AST node and associate that id with the node.

fn map_ast_with_parent(&self, ast: AstNode<'gcx>, parent: NodeId) -> NodeId

Call [map_ast] and [set_parent].

fn ast_of(&self, node_id: NodeId) -> Result<AstNode<'gcx>>

Obtain the AST node associated with a node id.

fn intern_type(&self, ty: TypeKind<'gcx>) -> Type<'gcx>

Internalize a type.

fn intern_value(&self, value: ValueData<'gcx>) -> Value<'gcx>

Internalize a value.

fn mkty_void(&self) -> Type<'gcx>

Make a void type.

fn mkty_time(&self) -> Type<'gcx>

Make a time type.

fn mkty_bit(&self) -> Type<'gcx>

Make a bit type.

fn mkty_logic(&self) -> Type<'gcx>

Make a logic type.

fn mkty_named(&self, name: Spanned<Name>, binding: NodeEnvId) -> Type<'gcx>

Make a named type.

fn mkty_int(&self, width: usize) -> Type<'gcx>

Make a 2-value integer type.

fn mkty_integer(&self, width: usize) -> Type<'gcx>

Make a 4-value integer type.

fn mkty_struct(&self, def_id: NodeId) -> Type<'gcx>

Make a struct type.

fn mkty_packed_array(&self, size: usize, elem_ty: Type<'gcx>) -> Type<'gcx>

Make a packed array type.

fn intern_param_env(&self, env: ParamEnvData<'gcx>) -> ParamEnv

Internalize a parameter environment.

fn param_env_data(&self, env: ParamEnv) -> &'gcx ParamEnvData<'gcx>

Get the ParamEnvData associated with a ParamEnv.

fn default_param_env(&self) -> ParamEnv

Get the default parameter environment.

fn add_param_env_context(&self, env: ParamEnv, context: NodeId)

Associate a context with a param env.

fn param_env_contexts(&self, env: ParamEnv) -> Vec<NodeId>

Get the contexts associated with a parameter environment.

fn set_parent(&self, node_id: NodeId, parent_id: NodeId)

Associate a parent with a node.

fn parent_node_id(&self, node_id: NodeId) -> Option<NodeId>

Find the parent node of a node.

fn is_parent_of(&self, parent_id: NodeId, child_id: NodeId) -> bool

Check if a node is the parent of another.

fn resolve_upwards_or_error(
    &self,
    name: Spanned<Name>,
    start_at: NodeId
) -> Result<NodeId>

Resolve a name upwards or emit a diagnostic if nothing is found.

fn resolve_downwards_or_error(
    &self,
    name: Spanned<Name>,
    start_at: NodeId
) -> Result<NodeId>

Resolve a name downwards or emit a diagnostic if nothing is found.

fn set_lowering_hint(&self, node_id: NodeId, hint: Hint)

Set a lowering hint on a node.

fn lowering_hint(&self, node_id: NodeId) -> Option<Hint>

Get a lowering hint on a node.

fn constant_int_value_of(
    &self,
    node_id: NodeId,
    env: ParamEnv
) -> Result<&'gcx BigInt>

Compute the constant value of a node and make sure it is an integer.

impl<'gcx> Context<'gcx> for GlobalContext<'gcx>

fn hir_of(&self, node_id: NodeId) -> Result<HirNode<'a>>

Lower an AST node to HIR.

fn param_env(&self, src: ParamEnvSource<'a>) -> Result<ParamEnv>

Compute the parameter bindings for an instantiation.

fn type_of(&self, node_id: NodeId, env: ParamEnv) -> Result<Type<'a>>

Determine the type of a node.

fn map_to_type(&self, node_id: NodeId, env: ParamEnv) -> Result<Type<'a>>

Convert a node to a type.

fn self_determined_type(
    &self,
    node_id: NodeId,
    env: ParamEnv
) -> Option<Type<'a>>

Get the self-determined type of a node.

fn need_self_determined_type(&self, node_id: NodeId, env: ParamEnv) -> Type<'a>

Require a node to have a self-determined type.

fn operation_type(&self, node_id: NodeId, env: ParamEnv) -> Option<Type<'a>>

Get the operation type of an expression.

fn need_operation_type(&self, node_id: NodeId, env: ParamEnv) -> Type<'a>

Require a node to have an operation type.

fn type_context(
    &self,
    node_id: NodeId,
    env: ParamEnv
) -> Option<TypeContext<'a>>

Get the type context of a node.

fn need_type_context(&self, node_id: NodeId, env: ParamEnv) -> TypeContext<'a>

Require a node to have a type context.

fn local_rib(&self, node_id: NodeId) -> Result<&'a Rib>

Determine the local rib that applies to a node.

fn hierarchical_rib(&self, node_id: NodeId) -> Result<&'a Rib>

Determine the hierarchical rib of a node.

fn resolve_upwards(
    &self,
    name: Name,
    start_at: NodeId
) -> Result<Option<NodeId>>

Resolve a name upwards through the ribs.

fn resolve_downwards(
    &self,
    name: Name,
    start_at: NodeId
) -> Result<Option<NodeId>>

Resolve a name downwards through the ribs.

fn resolve_node(&self, node_id: NodeId, env: ParamEnv) -> Result<NodeId>

Resolve a node to its target.

fn constant_value_of(&self, node_id: NodeId, env: ParamEnv) -> Result<Value<'a>>

Determine the constant value of a node.

fn is_constant(&self, node_id: NodeId) -> Result<bool>

Check if a node has a constant value.

fn type_default_value(&self, ty: Type<'a>) -> Value<'a>

Determine the default value of a type.

fn accessed_nodes(&self, node_id: NodeId) -> Result<Arc<AccessTable>>

Determine the nodes accessed by another node.

fn port_mapping(&self, src: PortMappingSource<'a>) -> Result<Arc<PortMapping>>

Compute the port assignments for an instantiation.

fn struct_def(&self, node_id: NodeId) -> Result<Arc<StructDef>>

Obtain the details of a struct definition.

fn resolve_field_access(
    &self,
    node_id: NodeId,
    env: ParamEnv
) -> Result<(NodeId, usize, NodeId)>

Resolve the field name in a field access expression.

fn mir_lvalue(&self, expr_id: NodeId, env: ParamEnv) -> &'a Lvalue<'a>

Lower an expression to an lvalue in the MIR.

fn mir_rvalue(&self, expr_id: NodeId, env: ParamEnv) -> &'a Rvalue<'a>

Lower an expression to an rvalue in the MIR.

impl<'_> DiagEmitter for GlobalContext<'_>

fn emit(&self, diag: DiagBuilder2)

Emit a diagnostic message.