Struct ParseCtxt

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

Fields

tcx: TyCtxt<'tcx>

typing_env: TypingEnv<'tcx>

thir: &'a Thir<'tcx>

source_scope: SourceScope

body: &'a mut Body<'tcx>

local_map: FxHashMap<LocalVarId, Local>

block_map: FxHashMap<LocalVarId, BasicBlock>

Implementations

impl<'a, 'tcx> ParseCtxt<'a, 'tcx>

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

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

fn parse_unwind_terminate_reason( &self, expr_id: ExprId, ) -> Result<UnwindTerminateReason, ParseError>

fn parse_unwind_action( &self, expr_id: ExprId, ) -> Result<UnwindAction, ParseError>

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

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

fn parse_call( &self, args: &[ExprId], ) -> Result<TerminatorKind<'tcx>, ParseError>

fn parse_tail_call( &self, args: &[ExprId], ) -> Result<TerminatorKind<'tcx>, ParseError>

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

pub(crate) 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<'a, 'tcx> ParseCtxt<'a, 'tcx>

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(crate) fn parse_args( &mut self, params: &IndexSlice<ParamId, Param<'tcx>>, ) -> Result<(), ParseError>

pub(crate) 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_basic_block_decl(&mut self, stmt: StmtId) -> Result<(), ParseError>

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

fn parse_debuginfo( &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, is_cleanup: bool, ) -> Result<BasicBlockData<'tcx>, ParseError>

impl<'a, 'tcx> ParseCtxt<'a, 'tcx>

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

fn stmt_error(&self, stmt: StmtId, 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: 120 bytes