Rewrite and refactor format_args!() builtin macro.
This commit is contained in:
Mara Bos
parent
d9297d22ad
commit
9bec0de397
7 changed files with 1245 additions and 1372 deletions
File diff suppressed because it is too large
Load diff
352
compiler/rustc_builtin_macros/src/format/expand.rs
Normal file
352
compiler/rustc_builtin_macros/src/format/expand.rs
Normal file
|
|
@ -0,0 +1,352 @@
|
|||
use super::*;
|
||||
use rustc_ast as ast;
|
||||
use rustc_ast::visit::{self, Visitor};
|
||||
use rustc_ast::{BlockCheckMode, UnsafeSource};
|
||||
use rustc_data_structures::fx::FxIndexSet;
|
||||
use rustc_span::{sym, symbol::kw};
|
||||
|
||||
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
|
||||
enum ArgumentType {
|
||||
Format(FormatTrait),
|
||||
Usize,
|
||||
}
|
||||
|
||||
fn make_argument(ecx: &ExtCtxt<'_>, sp: Span, arg: P<ast::Expr>, ty: ArgumentType) -> P<ast::Expr> {
|
||||
// Generate:
|
||||
// ::core::fmt::ArgumentV1::new_…(arg)
|
||||
use ArgumentType::*;
|
||||
use FormatTrait::*;
|
||||
ecx.expr_call_global(
|
||||
sp,
|
||||
ecx.std_path(&[
|
||||
sym::fmt,
|
||||
sym::ArgumentV1,
|
||||
match ty {
|
||||
Format(Display) => sym::new_display,
|
||||
Format(Debug) => sym::new_debug,
|
||||
Format(LowerExp) => sym::new_lower_exp,
|
||||
Format(UpperExp) => sym::new_upper_exp,
|
||||
Format(Octal) => sym::new_octal,
|
||||
Format(Pointer) => sym::new_pointer,
|
||||
Format(Binary) => sym::new_binary,
|
||||
Format(LowerHex) => sym::new_lower_hex,
|
||||
Format(UpperHex) => sym::new_upper_hex,
|
||||
Usize => sym::from_usize,
|
||||
},
|
||||
]),
|
||||
vec![arg],
|
||||
)
|
||||
}
|
||||
|
||||
fn make_count(
|
||||
ecx: &ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
count: &Option<FormatCount>,
|
||||
argmap: &mut FxIndexSet<(usize, ArgumentType)>,
|
||||
) -> P<ast::Expr> {
|
||||
// Generate:
|
||||
// ::core::fmt::rt::v1::Count::…(…)
|
||||
match count {
|
||||
Some(FormatCount::Literal(n)) => ecx.expr_call_global(
|
||||
sp,
|
||||
ecx.std_path(&[sym::fmt, sym::rt, sym::v1, sym::Count, sym::Is]),
|
||||
vec![ecx.expr_usize(sp, *n)],
|
||||
),
|
||||
Some(FormatCount::Argument(arg)) => {
|
||||
if let Ok(arg_index) = arg.index {
|
||||
let (i, _) = argmap.insert_full((arg_index, ArgumentType::Usize));
|
||||
ecx.expr_call_global(
|
||||
sp,
|
||||
ecx.std_path(&[sym::fmt, sym::rt, sym::v1, sym::Count, sym::Param]),
|
||||
vec![ecx.expr_usize(sp, i)],
|
||||
)
|
||||
} else {
|
||||
DummyResult::raw_expr(sp, true)
|
||||
}
|
||||
}
|
||||
None => ecx.expr_path(ecx.path_global(
|
||||
sp,
|
||||
ecx.std_path(&[sym::fmt, sym::rt, sym::v1, sym::Count, sym::Implied]),
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
fn make_format_spec(
|
||||
ecx: &ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
placeholder: &FormatPlaceholder,
|
||||
argmap: &mut FxIndexSet<(usize, ArgumentType)>,
|
||||
) -> P<ast::Expr> {
|
||||
// Generate:
|
||||
// ::core::fmt::rt::v1::Argument {
|
||||
// position: 0usize,
|
||||
// format: ::core::fmt::rt::v1::FormatSpec {
|
||||
// fill: ' ',
|
||||
// align: ::core::fmt::rt::v1::Alignment::Unknown,
|
||||
// flags: 0u32,
|
||||
// precision: ::core::fmt::rt::v1::Count::Implied,
|
||||
// width: ::core::fmt::rt::v1::Count::Implied,
|
||||
// },
|
||||
// }
|
||||
let position = match placeholder.argument.index {
|
||||
Ok(arg_index) => {
|
||||
let (i, _) =
|
||||
argmap.insert_full((arg_index, ArgumentType::Format(placeholder.format_trait)));
|
||||
ecx.expr_usize(sp, i)
|
||||
}
|
||||
Err(_) => DummyResult::raw_expr(sp, true),
|
||||
};
|
||||
let fill = ecx.expr_char(sp, placeholder.format_options.fill.unwrap_or(' '));
|
||||
let align = ecx.expr_path(ecx.path_global(
|
||||
sp,
|
||||
ecx.std_path(&[
|
||||
sym::fmt,
|
||||
sym::rt,
|
||||
sym::v1,
|
||||
sym::Alignment,
|
||||
match placeholder.format_options.alignment {
|
||||
Some(FormatAlignment::Left) => sym::Left,
|
||||
Some(FormatAlignment::Right) => sym::Right,
|
||||
Some(FormatAlignment::Center) => sym::Center,
|
||||
None => sym::Unknown,
|
||||
},
|
||||
]),
|
||||
));
|
||||
let flags = ecx.expr_u32(sp, placeholder.format_options.flags);
|
||||
let prec = make_count(ecx, sp, &placeholder.format_options.precision, argmap);
|
||||
let width = make_count(ecx, sp, &placeholder.format_options.width, argmap);
|
||||
ecx.expr_struct(
|
||||
sp,
|
||||
ecx.path_global(sp, ecx.std_path(&[sym::fmt, sym::rt, sym::v1, sym::Argument])),
|
||||
vec![
|
||||
ecx.field_imm(sp, Ident::new(sym::position, sp), position),
|
||||
ecx.field_imm(
|
||||
sp,
|
||||
Ident::new(sym::format, sp),
|
||||
ecx.expr_struct(
|
||||
sp,
|
||||
ecx.path_global(
|
||||
sp,
|
||||
ecx.std_path(&[sym::fmt, sym::rt, sym::v1, sym::FormatSpec]),
|
||||
),
|
||||
vec![
|
||||
ecx.field_imm(sp, Ident::new(sym::fill, sp), fill),
|
||||
ecx.field_imm(sp, Ident::new(sym::align, sp), align),
|
||||
ecx.field_imm(sp, Ident::new(sym::flags, sp), flags),
|
||||
ecx.field_imm(sp, Ident::new(sym::precision, sp), prec),
|
||||
ecx.field_imm(sp, Ident::new(sym::width, sp), width),
|
||||
],
|
||||
),
|
||||
),
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
pub fn expand_parsed_format_args(ecx: &mut ExtCtxt<'_>, fmt: FormatArgs) -> P<ast::Expr> {
|
||||
let macsp = ecx.with_def_site_ctxt(ecx.call_site());
|
||||
|
||||
let lit_pieces = ecx.expr_array_ref(
|
||||
fmt.span,
|
||||
fmt.template
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(i, piece)| match piece {
|
||||
&FormatArgsPiece::Literal(s) => Some(ecx.expr_str(fmt.span, s)),
|
||||
&FormatArgsPiece::Placeholder(_) => {
|
||||
// Inject empty string before placeholders when not already preceded by a literal piece.
|
||||
if i == 0 || matches!(fmt.template[i - 1], FormatArgsPiece::Placeholder(_)) {
|
||||
Some(ecx.expr_str(fmt.span, kw::Empty))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
})
|
||||
.collect(),
|
||||
);
|
||||
|
||||
let has_any_format_options = fmt.template.iter().any(|piece| {
|
||||
let FormatArgsPiece::Placeholder(placeholder) = piece else { return false };
|
||||
placeholder.format_options != Default::default()
|
||||
});
|
||||
|
||||
let (args, format_options) = if has_any_format_options {
|
||||
// Create a list of all _unique_ (argument, format trait) combinations.
|
||||
// E.g. "{0} {0:x} {0} {1}" -> [(0, Display), (0, LowerHex), (1, Display)]
|
||||
let mut argmap = FxIndexSet::default();
|
||||
// Generate:
|
||||
// &[format_spec_0, format_spec_1, format_spec_2]
|
||||
let format_options = ecx.expr_array_ref(
|
||||
macsp,
|
||||
fmt.template
|
||||
.iter()
|
||||
.filter_map(|piece| {
|
||||
let FormatArgsPiece::Placeholder(placeholder) = piece else { return None };
|
||||
Some(make_format_spec(ecx, macsp, placeholder, &mut argmap))
|
||||
})
|
||||
.collect(),
|
||||
);
|
||||
(Vec::from_iter(argmap), Some(format_options))
|
||||
} else {
|
||||
// Create a list of all (argument, format trait) pairs, one for each placeholder.
|
||||
// E.g. "{0} {0:x} {0} {1}" -> [(0, Display), (0, LowerHex), (0, Display), (1, Display)]
|
||||
let args = fmt
|
||||
.template
|
||||
.iter()
|
||||
.filter_map(|piece| {
|
||||
let FormatArgsPiece::Placeholder(placeholder) = piece else { return None };
|
||||
Some((
|
||||
placeholder.argument.index.ok()?,
|
||||
ArgumentType::Format(placeholder.format_trait),
|
||||
))
|
||||
})
|
||||
.collect();
|
||||
(args, None)
|
||||
};
|
||||
|
||||
// If the args array contains exactly all the original arguments once,
|
||||
// in order, we can use a simple array instead of a `match` construction.
|
||||
// However, if there's a yield point in any argument except the first one,
|
||||
// we don't do this, because an ArgumentV1 cannot be kept across yield points.
|
||||
let use_simple_array = args.len() == fmt.arguments.len()
|
||||
&& args.iter().enumerate().all(|(i, &(j, _))| i == j)
|
||||
&& fmt.arguments.iter().skip(1).all(|(arg, _)| !may_contain_yield_point(arg));
|
||||
|
||||
let args_expr = if use_simple_array {
|
||||
// Generate:
|
||||
// &[
|
||||
// ::core::fmt::ArgumentV1::new_display(&arg0),
|
||||
// ::core::fmt::ArgumentV1::new_lower_hex(&arg1),
|
||||
// ::core::fmt::ArgumentV1::new_debug(&arg2),
|
||||
// ]
|
||||
ecx.expr_array_ref(
|
||||
macsp,
|
||||
fmt.arguments
|
||||
.into_iter()
|
||||
.zip(args)
|
||||
.map(|((arg, _), (_, ty))| {
|
||||
let sp = arg.span.with_ctxt(macsp.ctxt());
|
||||
make_argument(ecx, sp, ecx.expr_addr_of(sp, arg), ty)
|
||||
})
|
||||
.collect(),
|
||||
)
|
||||
} else {
|
||||
// Generate:
|
||||
// match (&arg0, &arg1, &arg2) {
|
||||
// args => &[
|
||||
// ::core::fmt::ArgumentV1::new_display(args.0),
|
||||
// ::core::fmt::ArgumentV1::new_lower_hex(args.1),
|
||||
// ::core::fmt::ArgumentV1::new_debug(args.0),
|
||||
// ]
|
||||
// }
|
||||
let args_ident = Ident::new(sym::args, macsp);
|
||||
let args = args
|
||||
.iter()
|
||||
.map(|&(arg_index, ty)| {
|
||||
if let Some((arg, _)) = fmt.arguments.get(arg_index) {
|
||||
let sp = arg.span.with_ctxt(macsp.ctxt());
|
||||
make_argument(
|
||||
ecx,
|
||||
sp,
|
||||
ecx.expr_field(
|
||||
sp,
|
||||
ecx.expr_ident(macsp, args_ident),
|
||||
Ident::new(sym::integer(arg_index), macsp),
|
||||
),
|
||||
ty,
|
||||
)
|
||||
} else {
|
||||
DummyResult::raw_expr(macsp, true)
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
ecx.expr_addr_of(
|
||||
macsp,
|
||||
ecx.expr_match(
|
||||
macsp,
|
||||
ecx.expr_tuple(
|
||||
macsp,
|
||||
fmt.arguments
|
||||
.into_iter()
|
||||
.map(|(arg, _)| ecx.expr_addr_of(arg.span.with_ctxt(macsp.ctxt()), arg))
|
||||
.collect(),
|
||||
),
|
||||
[ecx.arm(macsp, ecx.pat_ident(macsp, args_ident), ecx.expr_array(macsp, args))]
|
||||
.into(),
|
||||
),
|
||||
)
|
||||
};
|
||||
|
||||
if let Some(format_options) = format_options {
|
||||
// Generate:
|
||||
// ::core::fmt::Arguments::new_v1_formatted(
|
||||
// lit_pieces,
|
||||
// args,
|
||||
// format_options,
|
||||
// unsafe { ::core::fmt::UnsafeArg::new() }
|
||||
// )
|
||||
ecx.expr_call_global(
|
||||
macsp,
|
||||
ecx.std_path(&[sym::fmt, sym::Arguments, sym::new_v1_formatted]),
|
||||
vec![
|
||||
lit_pieces,
|
||||
args_expr,
|
||||
format_options,
|
||||
ecx.expr_block(P(ast::Block {
|
||||
stmts: vec![ecx.stmt_expr(ecx.expr_call_global(
|
||||
macsp,
|
||||
ecx.std_path(&[sym::fmt, sym::UnsafeArg, sym::new]),
|
||||
Vec::new(),
|
||||
))],
|
||||
id: ast::DUMMY_NODE_ID,
|
||||
rules: BlockCheckMode::Unsafe(UnsafeSource::CompilerGenerated),
|
||||
span: macsp,
|
||||
tokens: None,
|
||||
could_be_bare_literal: false,
|
||||
})),
|
||||
],
|
||||
)
|
||||
} else {
|
||||
// Generate:
|
||||
// ::core::fmt::Arguments::new_v1(
|
||||
// lit_pieces,
|
||||
// args,
|
||||
// )
|
||||
ecx.expr_call_global(
|
||||
macsp,
|
||||
ecx.std_path(&[sym::fmt, sym::Arguments, sym::new_v1]),
|
||||
vec![lit_pieces, args_expr],
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fn may_contain_yield_point(e: &ast::Expr) -> bool {
|
||||
struct MayContainYieldPoint(bool);
|
||||
|
||||
impl Visitor<'_> for MayContainYieldPoint {
|
||||
fn visit_expr(&mut self, e: &ast::Expr) {
|
||||
if let ast::ExprKind::Await(_) | ast::ExprKind::Yield(_) = e.kind {
|
||||
self.0 = true;
|
||||
} else {
|
||||
visit::walk_expr(self, e);
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_mac_call(&mut self, _: &ast::MacCall) {
|
||||
self.0 = true;
|
||||
}
|
||||
|
||||
fn visit_attribute(&mut self, _: &ast::Attribute) {
|
||||
// Conservatively assume this may be a proc macro attribute in
|
||||
// expression position.
|
||||
self.0 = true;
|
||||
}
|
||||
|
||||
fn visit_item(&mut self, _: &ast::Item) {
|
||||
// Do not recurse into nested items.
|
||||
}
|
||||
}
|
||||
|
||||
let mut visitor = MayContainYieldPoint(false);
|
||||
visitor.visit_expr(e);
|
||||
visitor.0
|
||||
}
|
||||
|
|
@ -7,6 +7,7 @@
|
|||
#![feature(box_patterns)]
|
||||
#![feature(decl_macro)]
|
||||
#![feature(if_let_guard)]
|
||||
#![feature(is_some_with)]
|
||||
#![feature(is_sorted)]
|
||||
#![feature(let_chains)]
|
||||
#![feature(proc_macro_internals)]
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue