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.

Implementations

impl<'gcx> GlobalContext<'gcx>

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

Create a new global context.

pub fn add_root(&self, root: &'gcx Root<'gcx>)

Add an AST root to the context for processing.

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

pub fn add_files(&self, files: impl Iterator<Item = &'gcx SourceFile<'gcx>>)

Add an AST root with a series of source files to the context for processing.

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.

pub fn imports(&self) -> impl Iterator<Item = NodeId>

Get an iterator over all root imports in the AST.

Trait Implementations

impl<'gcx> Context<'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_span(&self, node_id: NodeId, span: Span)

Associate a span with a node 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 register_ast(&self, node: &'gcx dyn AnyNode<'gcx>)

Register an ast::AnyNode for later retrieval by ID.

fn ast_for_id(&self, node_id: NodeId) -> &'gcx dyn AnyNode<'gcx>

Obtain an ast::AnyNode associated with a node id.

fn intern_hir(&self, id: NodeId, hir: HirNode<'gcx>)

Internalize an HIR node.

fn intern_hir_with_parent(&self, id: NodeId, hir: HirNode<'gcx>, parent: NodeId)

Internalize an HIR node.

fn interned_hir(&self, id: NodeId) -> HirNode<'gcx>

Lookup an internalized HIR node.

fn get_interned_hir(&self, id: NodeId) -> Option<HirNode<'gcx>>

Lookup an internalized HIR node.

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

Internalize a value.

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 DiagEmitter for GlobalContext<'_>

fn emit(&self, diag: DiagBuilder2)

Emit a diagnostic message.

impl<'gcx> HasTypeStorage<'gcx> for GlobalContext<'gcx>

fn type_storage(&self) -> &'gcx TypeStorage<'gcx>

Get the type storage.

impl<'gcx> QueryDatabase<'gcx> for GlobalContext<'gcx>

type Context = Self

The type passed as first argument to compiler query implementations.

fn context(&self) -> &Self

Get the context that is passed to compiler query implementations.

fn storage(&self) -> &QueryStorage<'gcx>

Get the query caches and runtime data.

fn handle_cycle(&self) -> !

Called when a query cycle is detected.

fn before_query(&self, tag: &QueryTag<'a>)

Called before a query is executed.

fn after_query(&self, tag: &QueryTag<'a>)

Called after a query is executed.

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

Lower an AST node to HIR.

fn hir_of_module(&self, ast: &'a Module<'a>) -> Result<&'a Module<'a>>

Lower a module to HIR.

fn hir_of_interface(&self, ast: &'a Interface<'a>) -> Result<&'a Interface<'a>>

Lower an interface to HIR.

fn hir_of_expr(&self, arg0: Ref<'a, Expr<'a>>) -> Result<&'a Expr<'a>>

Lower an AST expression to HIR.

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

Determine the nodes accessed by another node.

fn inst_details(
    &self,
    arg0: Ref<'a, Inst<'a>>,
    env: ParamEnv
) -> Result<Arc<InstDetails<'a>>>

Compute the details of an instantiation.

fn inst_target_details(
    &self,
    arg0: Ref<'a, InstTarget<'a>>,
    env: ParamEnv
) -> Result<Arc<InstTargetDetails<'a>>>

Compute the details of an instantiated module or interface.

fn mir_assignment_from_procedural(
    &self,
    origin: NodeId,
    lhs: NodeId,
    rhs: NodeId,
    env: ParamEnv,
    span: Span,
    kind: AssignKind
) -> &'a Assignment<'a>

Lower a procedural assign statement.

fn mir_assignment_from_concurrent(
    &self,
    arg0: Ref<'a, Assign>,
    env: ParamEnv
) -> &'a Assignment<'a>

Lower a concurrent assign statement.

fn mir_simplify_assignment(
    &self,
    arg0: Ref<'a, Assignment<'a>>
) -> Vec<&'a Assignment<'a>>

Simplify an MIR assignment to potentially multiple simple MIR assignments.

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.

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

Compute the parameter bindings for an instantiation.

fn map_pattern(
    &self,
    arg0: Ref<'a, Expr<'a>>,
    env: ParamEnv
) -> Result<Arc<PatternMapping<'a>>>

Determine the mapping of a named or positional '{...} pattern.

fn canonicalize_ports(&self, node: &'a dyn PortedNode<'a>) -> &'a PortList<'a>

Resolve the ports of a module or interface to a canonical list.

fn port_mapping(
    &self,
    node: &'a dyn PortedNode<'a>,
    outer_env: ParamEnv,
    inner_env: ParamEnv,
    arg3: Ref<'a, InstName<'a>>,
    pos: &'a [PosParam],
    named: &'a [NamedParam],
    has_wildcard_port: bool
) -> Result<Arc<PortMapping<'a>>>

Compute the port assignments for an instantiation.

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.

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

Resolve a node to its target.

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<(usize, &'a StructMember<'a>)>

Resolve the field name in a field access expression.

fn generated_scope(&self, node: &'a dyn ScopedNode<'a>) -> &'a Scope<'a>

Determine the scope generated by a node.

fn scope_location(&self, node: &'a dyn AnyNode<'a>) -> ScopeLocation<'a>

Determine the location of a node within its enclosing scope.

fn resolve_local(
    &self,
    name: Name,
    at: ScopeLocation<'a>,
    skip_imports: bool
) -> Result<Option<&'a Def<'a>>>

Resolve a local name in a scope.

fn resolve_local_or_error(
    &self,
    name: Spanned<Name>,
    at: ScopeLocation<'a>,
    skip_imports: bool
) -> Result<&'a Def<'a>>

Resolve a local name in a scope or emit an error.

fn resolve_namespace(
    &self,
    name: Name,
    inside: &'a dyn ScopedNode<'a>
) -> Option<&'a Def<'a>>

Resolve a name in a scope as a namespace lookup.

fn resolve_namespace_or_error(
    &self,
    name: Spanned<Name>,
    inside: &'a dyn ScopedNode<'a>
) -> Result<&'a Def<'a>>

Resolve a name in a scope as a namespace lookup or emit an error.

fn resolve_hierarchical(
    &self,
    name: Name,
    inside: &'a dyn ScopedNode<'a>
) -> Option<&'a Def<'a>>

Resolve a name in a scope as a hierarchical lookup.

fn resolve_hierarchical_or_error(
    &self,
    name: Spanned<Name>,
    inside: &'a dyn ScopedNode<'a>
) -> Result<&'a Def<'a>>

Resolve a name in a scope as a hierarchical lookup or emit an error.

fn resolve_imported_scope(
    &self,
    node: &'a ImportItem<'a>
) -> Result<&'a dyn ScopedNode<'a>>

Resolve an import to the scope it imports.

fn nameck(&self, node: &'a dyn AnyNode<'a>) -> bool

Recursively resolves names throughout the AST.

fn resolve_inst_target(&self, inst: &'a Inst<'a>) -> Result<InstTarget<'a>>

Resolve the target of an instantiation.

fn disamb_kind(&self, arg0: Ref<'a, dyn AnyNode<'a>>) -> Kind

Determine the kind of a node.

fn disamb_type_or_expr(
    &self,
    arg0: Ref<'a, TypeOrExpr<'a>>
) -> Result<&'a TypeOrExpr<'a>>

Disambiguate a type or expression.

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

Determine the type of a node.

fn type_of_int_port(
    &self,
    arg0: Ref<'a, IntPort<'a>>,
    env: ParamEnv
) -> &'a UnpackedType<'a>

Determine the type of an internal port.

fn type_of_ext_port(
    &self,
    arg0: Ref<'a, ExtPort<'a>>,
    env: ParamEnv
) -> &'a UnpackedType<'a>

Determine the type of an external port.

fn type_of_port_decl(
    &self,
    arg0: Ref<'a, VarDeclName<'a>>,
    env: ParamEnv
) -> &'a UnpackedType<'a>

Determine the type of a port declaration.

fn type_of_var_decl(
    &self,
    arg0: Ref<'a, VarDeclName<'a>>,
    env: ParamEnv
) -> &'a UnpackedType<'a>

Determine the type of a variable declaration.

fn type_of_net_decl(
    &self,
    arg0: Ref<'a, VarDeclName<'a>>,
    env: ParamEnv
) -> &'a UnpackedType<'a>

Determine the type of a net declaration.

fn type_of_struct_member(
    &self,
    arg0: Ref<'a, VarDeclName<'a>>,
    env: ParamEnv
) -> &'a UnpackedType<'a>

Determine the type of a struct member.

fn type_of_value_param(
    &self,
    arg0: Ref<'a, ParamValueDecl<'a>>,
    env: ParamEnv
) -> &'a UnpackedType<'a>

Determine the type of a value parameter.

fn type_of_inst(
    &self,
    arg0: Ref<'a, Inst<'a>>,
    env: ParamEnv
) -> &'a UnpackedType<'a>

Determine the type of an instance.

fn map_to_type(
    &self,
    arg0: Ref<'a, dyn AnyNode<'a>>,
    env: ParamEnv
) -> Option<&'a UnpackedType<'a>>

Map an AST node to the type it represents.

fn map_to_type_or_error(
    &self,
    ast: Ref<'a, dyn AnyNode<'a>>,
    env: ParamEnv
) -> &'a UnpackedType<'a>

Map an AST node to the type it represents.

fn packed_type_from_ast(
    &self,
    ast: Ref<'a, Type<'a>>,
    env: ParamEnv,
    implicit_default: Option<PackedCore<'a>>
) -> &'a UnpackedType<'a>

Map a type node in the AST to an packed type.

fn unpacked_type_from_ast(
    &self,
    ast_type: Ref<'a, Type<'a>>,
    arg1: Ref<'a, [TypeDim<'a>]>,
    env: ParamEnv,
    implicit_default: Option<PackedCore<'a>>
) -> &'a UnpackedType<'a>

Map a type node and unpacked dimensions in the AST to an unpacked type.

fn type_of_expr(
    &self,
    expr: Ref<'a, Expr<'a>>,
    env: ParamEnv
) -> &'a UnpackedType<'a>

Determine the type of an expression.

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

Get the cast type of a node.

fn cast_expr_type(&self, arg0: Ref<'a, Expr<'a>>, env: ParamEnv) -> CastType<'a>

Get the cast type of an expression.

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

Get the self-determined type of a node.

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

Require a node to have a self-determined type.

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

Get the operation type of an expression.

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

Require a node to have an operation type.

fn type_context(&self, onto: 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>

Get the type context of a node.

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

Determine the constant value of a node.

fn const_mir_rvalue_int(&self, mir: Ref<'a, Rvalue<'a>>) -> Result<&'a BigInt>

Determine the constant integer value of an MIR rvalue.

fn const_mir_rvalue_string(
    &self,
    mir: Ref<'a, Rvalue<'a>>
) -> Result<&'a Vec<u8>>

Determine the constant string value of an MIR rvalue.

fn const_mir_rvalue(&self, arg0: Ref<'a, Rvalue<'a>>) -> Value<'a>

Determine the constant value of an MIR rvalue.

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

Check if a node has a constant value.

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

Determine the default value of a type.