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
11macro_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 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 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 {
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 {
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 {
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}