Struct rustc_trait_selection::traits::const_evaluatable::AbstractConstBuilder

struct AbstractConstBuilder<'a, 'tcx> {
    tcx: TyCtxt<'tcx>,
    body: &'a Body<'tcx>,
    nodes: IndexVec<NodeId, WorkNode<'tcx>>,
    locals: IndexVec<Local, NodeId>,
    checked_op_locals: BitSet<Local>,
}

Fields

tcx: TyCtxt<'tcx>

body: &'a Body<'tcx>

nodes: IndexVec<NodeId, WorkNode<'tcx>>

The current WIP node tree.

We require all nodes to be used in the final abstract const, so we store this here. Note that we also consider nodes as used if they are mentioned in an assert, so some used nodes are never actually reachable by walking the AbstractConst.

locals: IndexVec<Local, NodeId>

checked_op_locals: BitSet<Local>

We only allow field accesses if they access the result of a checked operation.

Implementations

impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx>

fn error(&mut self, span: Option<Span>, msg: &str) -> Result<!, ErrorReported>

fn new(
    tcx: TyCtxt<'tcx>,
    body: &'a Body<'tcx>
) -> Result<Option<AbstractConstBuilder<'a, 'tcx>>, ErrorReported>

fn add_node(&mut self, node: Node<'tcx>, span: Span) -> NodeId

fn place_to_local(
    &mut self,
    span: Span,
    p: &Place<'tcx>
) -> Result<Local, ErrorReported>

fn operand_to_node(
    &mut self,
    span: Span,
    op: &Operand<'tcx>
) -> Result<NodeId, ErrorReported>

fn check_binop(op: BinOp) -> bool

We do not allow all binary operations in abstract consts, so filter disallowed ones.

fn check_unop(op: UnOp) -> bool

While we currently allow all unary operations, we still want to explicitly guard against future changes here.

fn build_statement(
    &mut self,
    stmt: &Statement<'tcx>
) -> Result<(), ErrorReported>

fn build_terminator(
    &mut self,
    terminator: &Terminator<'tcx>
) -> Result<Option<BasicBlock>, ErrorReported>

Possible return values:

• None: unsupported terminator, stop building
• Some(None): supported terminator, finish building
• Some(Some(block)): support terminator, build block next

fn build(self) -> Result<&'tcx [Node<'tcx>], ErrorReported>

Builds the abstract const by walking the mir from start to finish and bailing out when encountering an unsupported operation.

Layout

Note: Most layout information is completely unstable and may be different between compiler versions and platforms. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 96 bytes