Struct rustc_trait_selection::traits::const_evaluatable::AbstractConstBuilder

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

Fields

tcx: TyCtxt<'tcx>

body: &'a Body<'tcx>

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

The current WIP node tree.

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 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.