Struct rustc_mir_build::build::custom::ParseCtxt

struct ParseCtxt<'tcx, 'body> {
    tcx: TyCtxt<'tcx>,
    param_env: ParamEnv<'tcx>,
    thir: &'body Thir<'tcx>,
    source_scope: SourceScope,
    body: &'body mut Body<'tcx>,
    local_map: FxHashMap<LocalVarId, Local>,
    block_map: FxHashMap<LocalVarId, BasicBlock>,
}

Fields

tcx: TyCtxt<'tcx>

param_env: ParamEnv<'tcx>

thir: &'body Thir<'tcx>

source_scope: SourceScope

body: &'body mut Body<'tcx>

local_map: FxHashMap<LocalVarId, Local>

block_map: FxHashMap<LocalVarId, BasicBlock>

Implementations

impl<'tcx, 'body> ParseCtxt<'tcx, 'body>

pub fn parse_statement(
    &self,
    expr_id: ExprId
) -> Result<StatementKind<'tcx>, ParseError>

pub fn parse_terminator(
    &self,
    expr_id: ExprId
) -> Result<TerminatorKind<'tcx>, ParseError>

fn parse_match(
    &self,
    arms: &[ArmId],
    span: Span
) -> Result<SwitchTargets, ParseError>

fn parse_rvalue(&self, expr_id: ExprId) -> Result<Rvalue<'tcx>, ParseError>

fn parse_operand(&self, expr_id: ExprId) -> Result<Operand<'tcx>, ParseError>

fn parse_place(&self, expr_id: ExprId) -> Result<Place<'tcx>, ParseError>

fn parse_place_inner(
    &self,
    expr_id: ExprId
) -> Result<(Place<'tcx>, PlaceTy<'tcx>), ParseError>

fn parse_local(&self, expr_id: ExprId) -> Result<Local, ParseError>

fn parse_block(&self, expr_id: ExprId) -> Result<BasicBlock, ParseError>

fn parse_static(&self, expr_id: ExprId) -> Result<Operand<'tcx>, ParseError>

fn parse_integer_literal(&self, expr_id: ExprId) -> Result<u128, ParseError>

impl<'tcx, 'body> ParseCtxt<'tcx, 'body>

fn preparse(&self, expr_id: ExprId) -> ExprId

Expressions should only ever be matched on after preparsing them. This removes extra scopes we don’t care about.

fn statement_as_expr(&self, stmt_id: StmtId) -> Result<ExprId, ParseError>

pub fn parse_args(
    &mut self,
    params: &IndexVec<ParamId, Param<'tcx>>
) -> Result<(), ParseError>

pub fn parse_body(&mut self, expr_id: ExprId) -> Result<(), ParseError>

Bodies are of the form:

{
    let bb1: BasicBlock;
    let bb2: BasicBlock;
    {
        let RET: _;
        let local1;
        let local2;

        {
            { // entry block
                statement1;
                terminator1
            };

            bb1 = {
                statement2;
                terminator2
            };

            bb2 = {
                statement3;
                terminator3
            }

            RET
        }
    }
}

This allows us to easily parse the basic blocks declarations, local declarations, and basic block definitions in order.

fn parse_block_decls(
    &mut self,
    stmts: impl Iterator<Item = StmtId>
) -> Result<(), ParseError>

fn parse_local_decls(
    &mut self,
    stmts: impl Iterator<Item = StmtId>
) -> Result<(), ParseError>

fn parse_let_statement(
    &mut self,
    stmt_id: StmtId
) -> Result<(LocalVarId, Ty<'tcx>, Span), ParseError>

fn parse_var(
    &mut self,
    pat: &Pat<'tcx>
) -> Result<(LocalVarId, Ty<'tcx>, Span), ParseError>

fn parse_block_def(
    &self,
    expr_id: ExprId
) -> Result<BasicBlockData<'tcx>, ParseError>

impl<'tcx, 'body> ParseCtxt<'tcx, 'body>

fn expr_error(&self, expr: ExprId, expected: &'static str) -> ParseError

Layout

Note: Most layout information is completely unstable and may even differ between compilations. 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: 104 bytes