squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Don't destructure args tuple in format_args!

Browse source
This commit is contained in:
Cameron Steffen 2021-11-01 11:56:38 -05:00
parent 3326f19e89
commit a9a24d5106
7 changed files with 13 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
compiler/rustc_builtin_macros/src/format.rs
View file

@ -763,13 +763,8 @@ impl<'a, 'b> Context<'a, 'b> {
let mut locals = let mut locals =
Vec::with_capacity((0..self.args.len()).map(|i| self.arg_unique_types[i].len()).sum()); Vec::with_capacity((0..self.args.len()).map(|i| self.arg_unique_types[i].len()).sum());
let mut counts = Vec::with_capacity(self.count_args.len()); let mut counts = Vec::with_capacity(self.count_args.len());
let mut pats = Vec::with_capacity(self.args.len());
let mut heads = Vec::with_capacity(self.args.len()); let mut heads = Vec::with_capacity(self.args.len());
let names_pos: Vec<_> = (0..self.args.len())
.map(|i| Ident::from_str_and_span(&format!("arg{}", i), self.macsp))
.collect();
// First, build up the static array which will become our precompiled // First, build up the static array which will become our precompiled
// format "string" // format "string"
let pieces = self.ecx.expr_vec_slice(self.fmtsp, self.str_pieces); let pieces = self.ecx.expr_vec_slice(self.fmtsp, self.str_pieces);
@ -787,11 +782,8 @@ impl<'a, 'b> Context<'a, 'b> {
// of each variable because we don't want to move out of the arguments // of each variable because we don't want to move out of the arguments
// passed to this function. // passed to this function.
for (i, e) in self.args.into_iter().enumerate() { for (i, e) in self.args.into_iter().enumerate() {
let name = names_pos[i];
let span = self.ecx.with_def_site_ctxt(e.span);
pats.push(self.ecx.pat_ident(span, name));
for arg_ty in self.arg_unique_types[i].iter() { for arg_ty in self.arg_unique_types[i].iter() {
locals.push(Context::format_arg(self.ecx, self.macsp, e.span, arg_ty, name)); locals.push(Context::format_arg(self.ecx, self.macsp, e.span, arg_ty, i));
} }
heads.push(self.ecx.expr_addr_of(e.span, e)); heads.push(self.ecx.expr_addr_of(e.span, e));
} }
@ -800,9 +792,8 @@ impl<'a, 'b> Context<'a, 'b> {
Exact(i) => i, Exact(i) => i,
_ => panic!("should never happen"), _ => panic!("should never happen"),
}; };
let name = names_pos[index];
let span = spans_pos[index]; let span = spans_pos[index];
counts.push(Context::format_arg(self.ecx, self.macsp, span, &Count, name)); counts.push(Context::format_arg(self.ecx, self.macsp, span, &Count, index));
} }
// Now create a vector containing all the arguments // Now create a vector containing all the arguments
@ -838,7 +829,7 @@ impl<'a, 'b> Context<'a, 'b> {
// But the nested match expression is proved to perform not as well // But the nested match expression is proved to perform not as well
// as series of let's; the first approach does. // as series of let's; the first approach does.
let args_match = { let args_match = {
let pat = self.ecx.pat_tuple(self.macsp, pats); let pat = self.ecx.pat_ident(self.macsp, Ident::new(sym::_args, self.macsp));
let arm = self.ecx.arm(self.macsp, pat, args_array); let arm = self.ecx.arm(self.macsp, pat, args_array);
let head = self.ecx.expr(self.macsp, ast::ExprKind::Tup(heads)); let head = self.ecx.expr(self.macsp, ast::ExprKind::Tup(heads));
self.ecx.expr_match(self.macsp, head, vec![arm]) self.ecx.expr_match(self.macsp, head, vec![arm])
@ -877,10 +868,11 @@ impl<'a, 'b> Context<'a, 'b> {
macsp: Span, macsp: Span,
mut sp: Span, mut sp: Span,
ty: &ArgumentType, ty: &ArgumentType,
arg: Ident, arg_index: usize,
) -> P<ast::Expr> { ) -> P<ast::Expr> {
sp = ecx.with_def_site_ctxt(sp); sp = ecx.with_def_site_ctxt(sp);
let arg = ecx.expr_ident(sp, arg); let arg = ecx.expr_ident(sp, Ident::new(sym::_args, sp));
let arg = ecx.expr(sp, ast::ExprKind::Field(arg, Ident::new(sym::integer(arg_index), sp)));
let trait_ = match *ty { let trait_ = match *ty {
Placeholder(trait_) if trait_ == "<invalid>" => return DummyResult::raw_expr(sp, true), Placeholder(trait_) if trait_ == "<invalid>" => return DummyResult::raw_expr(sp, true),
Placeholder(trait_) => trait_, Placeholder(trait_) => trait_,

1
compiler/rustc_span/src/symbol.rs
View file

@ -271,6 +271,7 @@ symbols! {
__S, __S,
__next, __next,
__try_var, __try_var,
_args,
_d, _d,
_e, _e,
_task_context, _task_context,

2
src/test/pretty/dollar-crate.pp
View file

@ -12,7 +12,7 @@ fn main() {
{ {
::std::io::_print(::core::fmt::Arguments::new_v1(&["rust\n"], ::std::io::_print(::core::fmt::Arguments::new_v1(&["rust\n"],
&match () { &match () {
() => [], _args => [],
})); }));
}; };
} }

2
src/test/pretty/issue-4264.pp
View file

@ -45,7 +45,7 @@ pub fn bar() ({
as as
()) ())
{ {
() _args
=> =>
([] ([]
as as

4
src/test/ui/attributes/key-value-expansion.stderr
View file

@ -19,8 +19,8 @@ error: unexpected token: `{
let res = let res =
::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""], ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""],
&match (&"u8",) { &match (&"u8",) {
(arg0,) => _args =>
[::core::fmt::ArgumentV1::new(arg0, [::core::fmt::ArgumentV1::new(_args.0,
::core::fmt::Display::fmt)], ::core::fmt::Display::fmt)],
})); }));
res res

2
src/test/ui/closures/print/closure-print-generic-trim-off-verbose-2.stderr
View file

@ -9,7 +9,7 @@ LL | let c1 : () = c;
| expected due to this | expected due to this
| |
= note: expected unit type `()` = note: expected unit type `()`
found closure `[mod1::f<T>::{closure#0} closure_substs=(unavailable) substs=[T, _#25t, extern "rust-call" fn(()), _#26t]]` found closure `[mod1::f<T>::{closure#0} closure_substs=(unavailable) substs=[T, _#22t, extern "rust-call" fn(()), _#23t]]`
help: use parentheses to call this closure help: use parentheses to call this closure
| |
LL | let c1 : () = c(); LL | let c1 : () = c();

2
src/test/ui/closures/print/closure-print-generic-verbose-2.stderr
View file

@ -9,7 +9,7 @@ LL | let c1 : () = c;
| expected due to this | expected due to this
| |
= note: expected unit type `()` = note: expected unit type `()`
found closure `[f<T>::{closure#0} closure_substs=(unavailable) substs=[T, _#25t, extern "rust-call" fn(()), _#26t]]` found closure `[f<T>::{closure#0} closure_substs=(unavailable) substs=[T, _#22t, extern "rust-call" fn(()), _#23t]]`
help: use parentheses to call this closure help: use parentheses to call this closure
| |
LL | let c1 : () = c(); LL | let c1 : () = c();