Skip to main content

rustc_mir_build/builder/custom/
parse.rs

1use rustc_index::IndexSlice;
2use rustc_middle::mir::*;
3use rustc_middle::thir::*;
4use rustc_middle::ty::{self, Ty};
5use rustc_span::Span;
6
7use super::{PResult, ParseCtxt, ParseError};
8
9mod instruction;
10
11/// Helper macro for parsing custom MIR.
12///
13/// Example usage looks something like:
14/// ```rust,ignore (incomplete example)
15/// parse_by_kind!(
16///     self, // : &ParseCtxt
17///     expr_id, // what you're matching against
18///     "assignment", // the thing you're trying to parse
19///     @call("mir_assign", args) => { args[0] }, // match invocations of the `mir_assign` special function
20///     ExprKind::Assign { lhs, .. } => { lhs }, // match thir assignment expressions
21///     // no need for fallthrough case - reasonable error is automatically generated
22/// )
23/// ```
24macro_rules! parse_by_kind {
25    (
26        $self:ident,
27        $expr_id:expr,
28        $expr_name:pat,
29        $expected:literal,
30        $(
31            @call($name:ident, $args:ident) => $call_expr:expr,
32        )*
33        $(
34            @variant($adt:ident, $variant:ident) => $variant_expr:expr,
35        )*
36        $(
37            $pat:pat $(if $guard:expr)? => $expr:expr,
38        )*
39    ) => {{
40        let expr_id = $self.preparse($expr_id);
41        let expr = &$self.thir[expr_id];
42        tracing::debug!("Trying to parse {:?} as {}", expr.kind, $expected);
43        let $expr_name = expr;
44        match &expr.kind {
45            $(
46                ExprKind::Call { ty, fun: _, args: $args, .. } if {
47                    match ty.kind() {
48                        ty::FnDef(did, _) => {
49                            $self.tcx.is_diagnostic_item(rustc_span::sym::$name, *did)
50                        }
51                        _ => false,
52                    }
53                } => $call_expr,
54            )*
55            $(
56                ExprKind::Adt(AdtExpr { adt_def, variant_index, .. }) if {
57                    $self.tcx.is_diagnostic_item(rustc_span::sym::$adt, adt_def.did()) &&
58                    adt_def.variants()[*variant_index].name == rustc_span::sym::$variant
59                } => $variant_expr,
60            )*
61            $(
62                $pat $(if $guard)? => $expr,
63            )*
64            #[allow(unreachable_patterns)]
65            _ => return Err($self.expr_error(expr_id, $expected))
66        }
67    }};
68}
69pub(crate) use parse_by_kind;
70
71impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
72    /// Expressions should only ever be matched on after preparsing them. This removes extra scopes
73    /// we don't care about.
74    fn preparse(&self, expr_id: ExprId) -> ExprId {
75        let expr = &self.thir[expr_id];
76        match expr.kind {
77            ExprKind::Scope { value, .. } => self.preparse(value),
78            _ => expr_id,
79        }
80    }
81
82    fn statement_as_expr(&self, stmt_id: StmtId) -> PResult<ExprId> {
83        match &self.thir[stmt_id].kind {
84            StmtKind::Expr { expr, .. } => Ok(*expr),
85            kind @ StmtKind::Let { pattern, .. } => Err(ParseError {
86                span: pattern.span,
87                item_description: ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0:?}", kind))
    })format!("{kind:?}"),
88                expected: "expression".to_string(),
89            }),
90        }
91    }
92
93    pub(crate) fn parse_args(&mut self, params: &IndexSlice<ParamId, Param<'tcx>>) -> PResult<()> {
94        for param in params.iter() {
95            let (var, span) = {
96                let pat = param.pat.as_ref().unwrap();
97                match &pat.kind {
98                    PatKind::Binding { var, .. } => (*var, pat.span),
99                    _ => {
100                        return Err(ParseError {
101                            span: pat.span,
102                            item_description: ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0:?}", pat.kind))
    })format!("{:?}", pat.kind),
103                            expected: "local".to_string(),
104                        });
105                    }
106                }
107            };
108            let decl = LocalDecl::new(param.ty, span);
109            let local = self.body.local_decls.push(decl);
110            self.local_map.insert(var, local);
111        }
112
113        Ok(())
114    }
115
116    /// Bodies are of the form:
117    ///
118    /// ```text
119    /// {
120    ///     let bb1: BasicBlock;
121    ///     let bb2: BasicBlock;
122    ///     {
123    ///         let RET: _;
124    ///         let local1;
125    ///         let local2;
126    ///
127    ///         {
128    ///             { // entry block
129    ///                 statement1;
130    ///                 terminator1
131    ///             };
132    ///
133    ///             bb1 = {
134    ///                 statement2;
135    ///                 terminator2
136    ///             };
137    ///
138    ///             bb2 = {
139    ///                 statement3;
140    ///                 terminator3
141    ///             }
142    ///
143    ///             RET
144    ///         }
145    ///     }
146    /// }
147    /// ```
148    ///
149    /// This allows us to easily parse the basic blocks declarations, local declarations, and
150    /// basic block definitions in order.
151    pub(crate) fn parse_body(&mut self, expr_id: ExprId) -> PResult<()> {
152        let body = {
    let expr_id = self.preparse(expr_id);
    let expr = &self.thir[expr_id];
    {
        use ::tracing::__macro_support::Callsite as _;
        static __CALLSITE: ::tracing::callsite::DefaultCallsite =
            {
                static META: ::tracing::Metadata<'static> =
                    {
                        ::tracing_core::metadata::Metadata::new("event /rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs:152",
                            "rustc_mir_build::builder::custom::parse",
                            ::tracing::Level::DEBUG,
                            ::tracing_core::__macro_support::Option::Some("/rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs"),
                            ::tracing_core::__macro_support::Option::Some(152u32),
                            ::tracing_core::__macro_support::Option::Some("rustc_mir_build::builder::custom::parse"),
                            ::tracing_core::field::FieldSet::new(&["message"],
                                ::tracing_core::callsite::Identifier(&__CALLSITE)),
                            ::tracing::metadata::Kind::EVENT)
                    };
                ::tracing::callsite::DefaultCallsite::new(&META)
            };
        let enabled =
            ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::STATIC_MAX_LEVEL &&
                    ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::LevelFilter::current() &&
                {
                    let interest = __CALLSITE.interest();
                    !interest.is_never() &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest)
                };
        if enabled {
            (|value_set: ::tracing::field::ValueSet|
                        {
                            let meta = __CALLSITE.metadata();
                            ::tracing::Event::dispatch(meta, &value_set);
                            ;
                        })({
                    #[allow(unused_imports)]
                    use ::tracing::field::{debug, display, Value};
                    __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("Trying to parse {0:?} as {1}",
                                                        expr.kind, "whole body") as &dyn ::tracing::field::Value))])
                });
        } else { ; }
    };
    let _ = expr;
    match &expr.kind {
        ExprKind::Block { block } =>
            self.thir[*block].expr.unwrap(),
            #[allow(unreachable_patterns)]
            _ => return Err(self.expr_error(expr_id, "whole body")),
    }
}parse_by_kind!(self, expr_id, _, "whole body",
153            ExprKind::Block { block } => self.thir[*block].expr.unwrap(),
154        );
155        let (block_decls, rest) = {
    let expr_id = self.preparse(body);
    let expr = &self.thir[expr_id];
    {
        use ::tracing::__macro_support::Callsite as _;
        static __CALLSITE: ::tracing::callsite::DefaultCallsite =
            {
                static META: ::tracing::Metadata<'static> =
                    {
                        ::tracing_core::metadata::Metadata::new("event /rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs:155",
                            "rustc_mir_build::builder::custom::parse",
                            ::tracing::Level::DEBUG,
                            ::tracing_core::__macro_support::Option::Some("/rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs"),
                            ::tracing_core::__macro_support::Option::Some(155u32),
                            ::tracing_core::__macro_support::Option::Some("rustc_mir_build::builder::custom::parse"),
                            ::tracing_core::field::FieldSet::new(&["message"],
                                ::tracing_core::callsite::Identifier(&__CALLSITE)),
                            ::tracing::metadata::Kind::EVENT)
                    };
                ::tracing::callsite::DefaultCallsite::new(&META)
            };
        let enabled =
            ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::STATIC_MAX_LEVEL &&
                    ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::LevelFilter::current() &&
                {
                    let interest = __CALLSITE.interest();
                    !interest.is_never() &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest)
                };
        if enabled {
            (|value_set: ::tracing::field::ValueSet|
                        {
                            let meta = __CALLSITE.metadata();
                            ::tracing::Event::dispatch(meta, &value_set);
                            ;
                        })({
                    #[allow(unused_imports)]
                    use ::tracing::field::{debug, display, Value};
                    __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("Trying to parse {0:?} as {1}",
                                                        expr.kind, "body with block decls") as
                                                &dyn ::tracing::field::Value))])
                });
        } else { ; }
    };
    let _ = expr;
    match &expr.kind {
        ExprKind::Block { block } => {
            let block = &self.thir[*block];
            (&block.stmts, block.expr.unwrap())
        }
            #[allow(unreachable_patterns)]
            _ =>
            return Err(self.expr_error(expr_id, "body with block decls")),
    }
}parse_by_kind!(self, body, _, "body with block decls",
156            ExprKind::Block { block } => {
157                let block = &self.thir[*block];
158                (&block.stmts, block.expr.unwrap())
159            },
160        );
161        self.parse_block_decls(block_decls.iter().copied())?;
162
163        let (local_decls, rest) = {
    let expr_id = self.preparse(rest);
    let expr = &self.thir[expr_id];
    {
        use ::tracing::__macro_support::Callsite as _;
        static __CALLSITE: ::tracing::callsite::DefaultCallsite =
            {
                static META: ::tracing::Metadata<'static> =
                    {
                        ::tracing_core::metadata::Metadata::new("event /rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs:163",
                            "rustc_mir_build::builder::custom::parse",
                            ::tracing::Level::DEBUG,
                            ::tracing_core::__macro_support::Option::Some("/rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs"),
                            ::tracing_core::__macro_support::Option::Some(163u32),
                            ::tracing_core::__macro_support::Option::Some("rustc_mir_build::builder::custom::parse"),
                            ::tracing_core::field::FieldSet::new(&["message"],
                                ::tracing_core::callsite::Identifier(&__CALLSITE)),
                            ::tracing::metadata::Kind::EVENT)
                    };
                ::tracing::callsite::DefaultCallsite::new(&META)
            };
        let enabled =
            ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::STATIC_MAX_LEVEL &&
                    ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::LevelFilter::current() &&
                {
                    let interest = __CALLSITE.interest();
                    !interest.is_never() &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest)
                };
        if enabled {
            (|value_set: ::tracing::field::ValueSet|
                        {
                            let meta = __CALLSITE.metadata();
                            ::tracing::Event::dispatch(meta, &value_set);
                            ;
                        })({
                    #[allow(unused_imports)]
                    use ::tracing::field::{debug, display, Value};
                    __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("Trying to parse {0:?} as {1}",
                                                        expr.kind, "body with local decls") as
                                                &dyn ::tracing::field::Value))])
                });
        } else { ; }
    };
    let _ = expr;
    match &expr.kind {
        ExprKind::Block { block } => {
            let block = &self.thir[*block];
            (&block.stmts, block.expr.unwrap())
        }
            #[allow(unreachable_patterns)]
            _ =>
            return Err(self.expr_error(expr_id, "body with local decls")),
    }
}parse_by_kind!(self, rest, _, "body with local decls",
164            ExprKind::Block { block } => {
165                let block = &self.thir[*block];
166                (&block.stmts, block.expr.unwrap())
167            },
168        );
169        self.parse_local_decls(local_decls.iter().copied())?;
170
171        let (debuginfo, rest) = {
    let expr_id = self.preparse(rest);
    let expr = &self.thir[expr_id];
    {
        use ::tracing::__macro_support::Callsite as _;
        static __CALLSITE: ::tracing::callsite::DefaultCallsite =
            {
                static META: ::tracing::Metadata<'static> =
                    {
                        ::tracing_core::metadata::Metadata::new("event /rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs:171",
                            "rustc_mir_build::builder::custom::parse",
                            ::tracing::Level::DEBUG,
                            ::tracing_core::__macro_support::Option::Some("/rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs"),
                            ::tracing_core::__macro_support::Option::Some(171u32),
                            ::tracing_core::__macro_support::Option::Some("rustc_mir_build::builder::custom::parse"),
                            ::tracing_core::field::FieldSet::new(&["message"],
                                ::tracing_core::callsite::Identifier(&__CALLSITE)),
                            ::tracing::metadata::Kind::EVENT)
                    };
                ::tracing::callsite::DefaultCallsite::new(&META)
            };
        let enabled =
            ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::STATIC_MAX_LEVEL &&
                    ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::LevelFilter::current() &&
                {
                    let interest = __CALLSITE.interest();
                    !interest.is_never() &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest)
                };
        if enabled {
            (|value_set: ::tracing::field::ValueSet|
                        {
                            let meta = __CALLSITE.metadata();
                            ::tracing::Event::dispatch(meta, &value_set);
                            ;
                        })({
                    #[allow(unused_imports)]
                    use ::tracing::field::{debug, display, Value};
                    __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("Trying to parse {0:?} as {1}",
                                                        expr.kind, "body with debuginfo") as
                                                &dyn ::tracing::field::Value))])
                });
        } else { ; }
    };
    let _ = expr;
    match &expr.kind {
        ExprKind::Block { block } => {
            let block = &self.thir[*block];
            (&block.stmts, block.expr.unwrap())
        }
            #[allow(unreachable_patterns)]
            _ => return Err(self.expr_error(expr_id, "body with debuginfo")),
    }
}parse_by_kind!(self, rest, _, "body with debuginfo",
172            ExprKind::Block { block } => {
173                let block = &self.thir[*block];
174                (&block.stmts, block.expr.unwrap())
175            },
176        );
177        self.parse_debuginfo(debuginfo.iter().copied())?;
178
179        let block_defs = {
    let expr_id = self.preparse(rest);
    let expr = &self.thir[expr_id];
    {
        use ::tracing::__macro_support::Callsite as _;
        static __CALLSITE: ::tracing::callsite::DefaultCallsite =
            {
                static META: ::tracing::Metadata<'static> =
                    {
                        ::tracing_core::metadata::Metadata::new("event /rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs:179",
                            "rustc_mir_build::builder::custom::parse",
                            ::tracing::Level::DEBUG,
                            ::tracing_core::__macro_support::Option::Some("/rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs"),
                            ::tracing_core::__macro_support::Option::Some(179u32),
                            ::tracing_core::__macro_support::Option::Some("rustc_mir_build::builder::custom::parse"),
                            ::tracing_core::field::FieldSet::new(&["message"],
                                ::tracing_core::callsite::Identifier(&__CALLSITE)),
                            ::tracing::metadata::Kind::EVENT)
                    };
                ::tracing::callsite::DefaultCallsite::new(&META)
            };
        let enabled =
            ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::STATIC_MAX_LEVEL &&
                    ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::LevelFilter::current() &&
                {
                    let interest = __CALLSITE.interest();
                    !interest.is_never() &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest)
                };
        if enabled {
            (|value_set: ::tracing::field::ValueSet|
                        {
                            let meta = __CALLSITE.metadata();
                            ::tracing::Event::dispatch(meta, &value_set);
                            ;
                        })({
                    #[allow(unused_imports)]
                    use ::tracing::field::{debug, display, Value};
                    __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("Trying to parse {0:?} as {1}",
                                                        expr.kind, "body with block defs") as
                                                &dyn ::tracing::field::Value))])
                });
        } else { ; }
    };
    let _ = expr;
    match &expr.kind {
        ExprKind::Block { block } =>
            &self.thir[*block].stmts,
            #[allow(unreachable_patterns)]
            _ => return Err(self.expr_error(expr_id, "body with block defs")),
    }
}parse_by_kind!(self, rest, _, "body with block defs",
180            ExprKind::Block { block } => &self.thir[*block].stmts,
181        );
182        for (i, block_def) in block_defs.iter().enumerate() {
183            let bb = BasicBlock::from_usize(i);
184            let is_cleanup = self.block_decls[bb];
185            let block = self.parse_block_def(self.statement_as_expr(*block_def)?, is_cleanup)?;
186            let inserted_bb = self.body.basic_blocks_mut().push(block);
187            // just a sanity check to make sure that we inserted the block
188            // to the correct position (basic block idx)
189            {
    match (&inserted_bb, &bb) {
        (left_val, right_val) => {
            if !(*left_val == *right_val) {
                let kind = ::core::panicking::AssertKind::Eq;
                ::core::panicking::assert_failed(kind, &*left_val,
                    &*right_val, ::core::option::Option::None);
            }
        }
    }
};assert_eq!(inserted_bb, bb);
190        }
191        // check that declarations, definitions and block_map counts match
192        {
    match (&self.block_decls.len(), &self.body.basic_blocks.len()) {
        (left_val, right_val) => {
            if !(*left_val == *right_val) {
                let kind = ::core::panicking::AssertKind::Eq;
                ::core::panicking::assert_failed(kind, &*left_val,
                    &*right_val, ::core::option::Option::None);
            }
        }
    }
};assert_eq!(self.block_decls.len(), self.body.basic_blocks.len());
193        // +1 because block_map doesn't contain the entry block
194        {
    match (&self.block_decls.len(), &(self.block_map.len() + 1)) {
        (left_val, right_val) => {
            if !(*left_val == *right_val) {
                let kind = ::core::panicking::AssertKind::Eq;
                ::core::panicking::assert_failed(kind, &*left_val,
                    &*right_val, ::core::option::Option::None);
            }
        }
    }
};assert_eq!(self.block_decls.len(), self.block_map.len() + 1);
195
196        Ok(())
197    }
198
199    fn parse_block_decls(&mut self, stmts: impl Iterator<Item = StmtId>) -> PResult<()> {
200        for stmt in stmts {
201            self.parse_basic_block_decl(stmt)?;
202        }
203        Ok(())
204    }
205
206    fn parse_basic_block_decl(&mut self, stmt: StmtId) -> PResult<()> {
207        match &self.thir[stmt].kind {
208            StmtKind::Let { pattern, initializer: Some(initializer), .. } => {
209                let (var, ..) = self.parse_var(pattern)?;
210                let is_cleanup = {
    let expr_id = self.preparse(*initializer);
    let expr = &self.thir[expr_id];
    {
        use ::tracing::__macro_support::Callsite as _;
        static __CALLSITE: ::tracing::callsite::DefaultCallsite =
            {
                static META: ::tracing::Metadata<'static> =
                    {
                        ::tracing_core::metadata::Metadata::new("event /rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs:210",
                            "rustc_mir_build::builder::custom::parse",
                            ::tracing::Level::DEBUG,
                            ::tracing_core::__macro_support::Option::Some("/rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs"),
                            ::tracing_core::__macro_support::Option::Some(210u32),
                            ::tracing_core::__macro_support::Option::Some("rustc_mir_build::builder::custom::parse"),
                            ::tracing_core::field::FieldSet::new(&["message"],
                                ::tracing_core::callsite::Identifier(&__CALLSITE)),
                            ::tracing::metadata::Kind::EVENT)
                    };
                ::tracing::callsite::DefaultCallsite::new(&META)
            };
        let enabled =
            ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::STATIC_MAX_LEVEL &&
                    ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::LevelFilter::current() &&
                {
                    let interest = __CALLSITE.interest();
                    !interest.is_never() &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest)
                };
        if enabled {
            (|value_set: ::tracing::field::ValueSet|
                        {
                            let meta = __CALLSITE.metadata();
                            ::tracing::Event::dispatch(meta, &value_set);
                            ;
                        })({
                    #[allow(unused_imports)]
                    use ::tracing::field::{debug, display, Value};
                    __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("Trying to parse {0:?} as {1}",
                                                        expr.kind, "basic block declaration") as
                                                &dyn ::tracing::field::Value))])
                });
        } else { ; }
    };
    let _ = expr;
    match &expr.kind {
        ExprKind::Adt(AdtExpr { adt_def, variant_index, .. }) if
            {
                self.tcx.is_diagnostic_item(rustc_span::sym::mir_basic_block,
                        adt_def.did()) &&
                    adt_def.variants()[*variant_index].name ==
                        rustc_span::sym::Normal
            } => false,
        ExprKind::Adt(AdtExpr { adt_def, variant_index, .. }) if
            {
                self.tcx.is_diagnostic_item(rustc_span::sym::mir_basic_block,
                        adt_def.did()) &&
                    adt_def.variants()[*variant_index].name ==
                        rustc_span::sym::Cleanup
            } =>
            true,
            #[allow(unreachable_patterns)]
            _ =>
            return Err(self.expr_error(expr_id, "basic block declaration")),
    }
}parse_by_kind!(self, *initializer, _, "basic block declaration",
211                    @variant(mir_basic_block, Normal) => false,
212                    @variant(mir_basic_block, Cleanup) => true,
213                );
214                let block = self.block_decls.push(is_cleanup);
215                self.block_map.insert(var, block);
216                Ok(())
217            }
218            _ => Err(self.stmt_error(stmt, "let statement with an initializer")),
219        }
220    }
221
222    fn parse_local_decls(&mut self, mut stmts: impl Iterator<Item = StmtId>) -> PResult<()> {
223        let (ret_var, ..) = self.parse_let_statement(stmts.next().unwrap())?;
224        self.local_map.insert(ret_var, Local::ZERO);
225
226        for stmt in stmts {
227            let (var, ty, span) = self.parse_let_statement(stmt)?;
228            let decl = LocalDecl::new(ty, span);
229            let local = self.body.local_decls.push(decl);
230            self.local_map.insert(var, local);
231        }
232
233        Ok(())
234    }
235
236    fn parse_debuginfo(&mut self, stmts: impl Iterator<Item = StmtId>) -> PResult<()> {
237        for stmt in stmts {
238            let stmt = &self.thir[stmt];
239            let expr = match stmt.kind {
240                StmtKind::Let { span, .. } => {
241                    return Err(ParseError {
242                        span,
243                        item_description: ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0:?}", stmt))
    })format!("{:?}", stmt),
244                        expected: "debuginfo".to_string(),
245                    });
246                }
247                StmtKind::Expr { expr, .. } => expr,
248            };
249            let span = self.thir[expr].span;
250            let (name, operand) = {
    let expr_id = self.preparse(expr);
    let expr = &self.thir[expr_id];
    {
        use ::tracing::__macro_support::Callsite as _;
        static __CALLSITE: ::tracing::callsite::DefaultCallsite =
            {
                static META: ::tracing::Metadata<'static> =
                    {
                        ::tracing_core::metadata::Metadata::new("event /rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs:250",
                            "rustc_mir_build::builder::custom::parse",
                            ::tracing::Level::DEBUG,
                            ::tracing_core::__macro_support::Option::Some("/rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs"),
                            ::tracing_core::__macro_support::Option::Some(250u32),
                            ::tracing_core::__macro_support::Option::Some("rustc_mir_build::builder::custom::parse"),
                            ::tracing_core::field::FieldSet::new(&["message"],
                                ::tracing_core::callsite::Identifier(&__CALLSITE)),
                            ::tracing::metadata::Kind::EVENT)
                    };
                ::tracing::callsite::DefaultCallsite::new(&META)
            };
        let enabled =
            ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::STATIC_MAX_LEVEL &&
                    ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::LevelFilter::current() &&
                {
                    let interest = __CALLSITE.interest();
                    !interest.is_never() &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest)
                };
        if enabled {
            (|value_set: ::tracing::field::ValueSet|
                        {
                            let meta = __CALLSITE.metadata();
                            ::tracing::Event::dispatch(meta, &value_set);
                            ;
                        })({
                    #[allow(unused_imports)]
                    use ::tracing::field::{debug, display, Value};
                    __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("Trying to parse {0:?} as {1}",
                                                        expr.kind, "debuginfo") as &dyn ::tracing::field::Value))])
                });
        } else { ; }
    };
    let _ = expr;
    match &expr.kind {
        ExprKind::Call { ty, fun: _, args: args, .. } if
            {
                match ty.kind() {
                    ty::FnDef(did, _) => {
                        self.tcx.is_diagnostic_item(rustc_span::sym::mir_debuginfo,
                            *did)
                    }
                    _ => false,
                }
            } => {
            (args[0], args[1])
        }
            #[allow(unreachable_patterns)]
            _ => return Err(self.expr_error(expr_id, "debuginfo")),
    }
}parse_by_kind!(self, expr, _, "debuginfo",
251                @call(mir_debuginfo, args) => {
252                    (args[0], args[1])
253                },
254            );
255            let name = {
    let expr_id = self.preparse(name);
    let expr = &self.thir[expr_id];
    {
        use ::tracing::__macro_support::Callsite as _;
        static __CALLSITE: ::tracing::callsite::DefaultCallsite =
            {
                static META: ::tracing::Metadata<'static> =
                    {
                        ::tracing_core::metadata::Metadata::new("event /rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs:255",
                            "rustc_mir_build::builder::custom::parse",
                            ::tracing::Level::DEBUG,
                            ::tracing_core::__macro_support::Option::Some("/rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs"),
                            ::tracing_core::__macro_support::Option::Some(255u32),
                            ::tracing_core::__macro_support::Option::Some("rustc_mir_build::builder::custom::parse"),
                            ::tracing_core::field::FieldSet::new(&["message"],
                                ::tracing_core::callsite::Identifier(&__CALLSITE)),
                            ::tracing::metadata::Kind::EVENT)
                    };
                ::tracing::callsite::DefaultCallsite::new(&META)
            };
        let enabled =
            ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::STATIC_MAX_LEVEL &&
                    ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::LevelFilter::current() &&
                {
                    let interest = __CALLSITE.interest();
                    !interest.is_never() &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest)
                };
        if enabled {
            (|value_set: ::tracing::field::ValueSet|
                        {
                            let meta = __CALLSITE.metadata();
                            ::tracing::Event::dispatch(meta, &value_set);
                            ;
                        })({
                    #[allow(unused_imports)]
                    use ::tracing::field::{debug, display, Value};
                    __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("Trying to parse {0:?} as {1}",
                                                        expr.kind, "debuginfo") as &dyn ::tracing::field::Value))])
                });
        } else { ; }
    };
    let _ = expr;
    match &expr.kind {
        ExprKind::Literal { lit, neg: false } =>
            lit,
            #[allow(unreachable_patterns)]
            _ => return Err(self.expr_error(expr_id, "debuginfo")),
    }
}parse_by_kind!(self, name, _, "debuginfo",
256                ExprKind::Literal { lit, neg: false } => lit,
257            );
258            let Some(name) = name.node.str() else {
259                return Err(ParseError {
260                    span,
261                    item_description: ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0:?}", name))
    })format!("{:?}", name),
262                    expected: "string".to_string(),
263                });
264            };
265            let operand = self.parse_operand(operand)?;
266            let value = match operand {
267                Operand::Constant(c) => VarDebugInfoContents::Const(*c),
268                Operand::Copy(p) | Operand::Move(p) => VarDebugInfoContents::Place(p),
269                Operand::RuntimeChecks(_) => ::core::panicking::unreachable_default_msg()unreachable!(),
270            };
271            let dbginfo = VarDebugInfo {
272                name,
273                source_info: SourceInfo { span, scope: self.source_scope },
274                composite: None,
275                argument_index: None,
276                value,
277            };
278            self.body.var_debug_info.push(dbginfo);
279        }
280
281        Ok(())
282    }
283
284    fn parse_let_statement(&mut self, stmt_id: StmtId) -> PResult<(LocalVarId, Ty<'tcx>, Span)> {
285        let pattern = match &self.thir[stmt_id].kind {
286            StmtKind::Let { pattern, .. } => pattern,
287            StmtKind::Expr { expr, .. } => {
288                return Err(self.expr_error(*expr, "let statement"));
289            }
290        };
291
292        self.parse_var(pattern)
293    }
294
295    fn parse_var(&mut self, pat: &Pat<'tcx>) -> PResult<(LocalVarId, Ty<'tcx>, Span)> {
296        match &pat.kind {
297            PatKind::Binding { var, ty, .. } => Ok((*var, *ty, pat.span)),
298            _ => Err(ParseError {
299                span: pat.span,
300                item_description: ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0:?}", pat.kind))
    })format!("{:?}", pat.kind),
301                expected: "local".to_string(),
302            }),
303        }
304    }
305
306    fn parse_block_def(&self, expr_id: ExprId, is_cleanup: bool) -> PResult<BasicBlockData<'tcx>> {
307        let block = {
    let expr_id = self.preparse(expr_id);
    let expr = &self.thir[expr_id];
    {
        use ::tracing::__macro_support::Callsite as _;
        static __CALLSITE: ::tracing::callsite::DefaultCallsite =
            {
                static META: ::tracing::Metadata<'static> =
                    {
                        ::tracing_core::metadata::Metadata::new("event /rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs:307",
                            "rustc_mir_build::builder::custom::parse",
                            ::tracing::Level::DEBUG,
                            ::tracing_core::__macro_support::Option::Some("/rustc-dev/59cbdee2e7b3ee50e44b460561c43c9e3023d9f0/compiler/rustc_mir_build/src/builder/custom/parse.rs"),
                            ::tracing_core::__macro_support::Option::Some(307u32),
                            ::tracing_core::__macro_support::Option::Some("rustc_mir_build::builder::custom::parse"),
                            ::tracing_core::field::FieldSet::new(&["message"],
                                ::tracing_core::callsite::Identifier(&__CALLSITE)),
                            ::tracing::metadata::Kind::EVENT)
                    };
                ::tracing::callsite::DefaultCallsite::new(&META)
            };
        let enabled =
            ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::STATIC_MAX_LEVEL &&
                    ::tracing::Level::DEBUG <=
                        ::tracing::level_filters::LevelFilter::current() &&
                {
                    let interest = __CALLSITE.interest();
                    !interest.is_never() &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest)
                };
        if enabled {
            (|value_set: ::tracing::field::ValueSet|
                        {
                            let meta = __CALLSITE.metadata();
                            ::tracing::Event::dispatch(meta, &value_set);
                            ;
                        })({
                    #[allow(unused_imports)]
                    use ::tracing::field::{debug, display, Value};
                    __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("Trying to parse {0:?} as {1}",
                                                        expr.kind, "basic block") as
                                                &dyn ::tracing::field::Value))])
                });
        } else { ; }
    };
    let _ = expr;
    match &expr.kind {
        ExprKind::Block { block } =>
            &self.thir[*block],
            #[allow(unreachable_patterns)]
            _ => return Err(self.expr_error(expr_id, "basic block")),
    }
}parse_by_kind!(self, expr_id, _, "basic block",
308            ExprKind::Block { block } => &self.thir[*block],
309        );
310
311        let mut statements = ::alloc::vec::Vec::new()vec![];
312        for stmt_id in &*block.stmts {
313            let stmt = self.statement_as_expr(*stmt_id)?;
314            let span = self.thir[stmt].span;
315            let statement = self.parse_statement(stmt)?;
316            statements
317                .push(Statement::new(SourceInfo { span, scope: self.source_scope }, statement));
318        }
319
320        let Some(trailing) = block.expr else { return Err(self.expr_error(expr_id, "terminator")) };
321        let span = self.thir[trailing].span;
322        let terminator = self.parse_terminator(trailing)?;
323
324        let terminator = Terminator {
325            source_info: SourceInfo { span, scope: self.source_scope },
326            kind: terminator,
327        };
328
329        Ok(BasicBlockData::new_stmts(statements, terminator, is_cleanup))
330    }
331}