Rollup merge of #93155 - dtolnay:blockindent, r=nagisa
Switch pretty printer to block-based indentation
This PR backports 401d60c042 from the `prettyplease` crate into `rustc_ast_pretty`.
A before and after:
```diff
- let res =
- ((::alloc::fmt::format as
- for<'r> fn(Arguments<'r>) -> String {format})(((::core::fmt::Arguments::new_v1
- as
- fn(&[&'static str], &[ArgumentV1]) -> Arguments {Arguments::new_v1})((&([("test"
- as
- &str)]
- as
- [&str; 1])
- as
- &[&str; 1]),
- (&([]
- as
- [ArgumentV1; 0])
- as
- &[ArgumentV1; 0]))
- as
- Arguments))
- as String);
+ let res =
+ ((::alloc::fmt::format as
+ for<'r> fn(Arguments<'r>) -> String {format})(((::core::fmt::Arguments::new_v1
+ as
+ fn(&[&'static str], &[ArgumentV1]) -> Arguments {Arguments::new_v1})((&([("test"
+ as &str)] as [&str; 1]) as
+ &[&str; 1]),
+ (&([] as [ArgumentV1; 0]) as &[ArgumentV1; 0])) as
+ Arguments)) as String);
```
Previously the pretty printer would compute indentation always relative to whatever column a block begins at, like this:
```rust
fn demo(arg1: usize,
arg2: usize);
```
This is never the thing to do in the dominant contemporary Rust style. Rustfmt's default and the style used by the vast majority of Rust codebases is block indentation:
```rust
fn demo(
arg1: usize,
arg2: usize,
);
```
where every indentation level is a multiple of 4 spaces and each level is indented relative to the indentation of the previous line, not the position that the block starts in.
By itself this PR doesn't get perfect formatting in all cases, but it is the smallest possible step in clearly the right direction. More backports from `prettyplease` to tune the ibox/cbox indent levels around various AST node types are upcoming.
This commit is contained in:
Matthias Krüger
GitHub
commit
1cb22e4138
22 changed files with 276 additions and 263 deletions
|
|
@ -146,6 +146,22 @@ pub enum Breaks {
|
|||
Inconsistent,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
enum IndentStyle {
|
||||
/// Vertically aligned under whatever column this block begins at.
|
||||
///
|
||||
/// fn demo(arg1: usize,
|
||||
/// arg2: usize);
|
||||
Visual,
|
||||
/// Indented relative to the indentation level of the previous line.
|
||||
///
|
||||
/// fn demo(
|
||||
/// arg1: usize,
|
||||
/// arg2: usize,
|
||||
/// );
|
||||
Block { offset: isize },
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub struct BreakToken {
|
||||
offset: isize,
|
||||
|
|
@ -154,7 +170,7 @@ pub struct BreakToken {
|
|||
|
||||
#[derive(Clone, Copy)]
|
||||
pub struct BeginToken {
|
||||
offset: isize,
|
||||
indent: IndentStyle,
|
||||
breaks: Breaks,
|
||||
}
|
||||
|
||||
|
|
@ -178,7 +194,7 @@ impl Token {
|
|||
#[derive(Copy, Clone)]
|
||||
enum PrintFrame {
|
||||
Fits,
|
||||
Broken { offset: isize, breaks: Breaks },
|
||||
Broken { indent: usize, breaks: Breaks },
|
||||
}
|
||||
|
||||
const SIZE_INFINITY: isize = 0xffff;
|
||||
|
|
@ -204,6 +220,8 @@ pub struct Printer {
|
|||
scan_stack: VecDeque<usize>,
|
||||
/// Stack of blocks-in-progress being flushed by print
|
||||
print_stack: Vec<PrintFrame>,
|
||||
/// Level of indentation of current line
|
||||
indent: usize,
|
||||
/// Buffered indentation to avoid writing trailing whitespace
|
||||
pending_indentation: isize,
|
||||
/// The token most recently popped from the left boundary of the
|
||||
|
|
@ -229,6 +247,7 @@ impl Printer {
|
|||
right_total: 0,
|
||||
scan_stack: VecDeque::new(),
|
||||
print_stack: Vec::new(),
|
||||
indent: 0,
|
||||
pending_indentation: 0,
|
||||
last_printed: None,
|
||||
}
|
||||
|
|
@ -368,38 +387,41 @@ impl Printer {
|
|||
*self
|
||||
.print_stack
|
||||
.last()
|
||||
.unwrap_or(&PrintFrame::Broken { offset: 0, breaks: Breaks::Inconsistent })
|
||||
.unwrap_or(&PrintFrame::Broken { indent: 0, breaks: Breaks::Inconsistent })
|
||||
}
|
||||
|
||||
fn print_begin(&mut self, token: BeginToken, size: isize) {
|
||||
if size > self.space {
|
||||
let col = self.margin - self.space + token.offset;
|
||||
self.print_stack.push(PrintFrame::Broken { offset: col, breaks: token.breaks });
|
||||
self.print_stack.push(PrintFrame::Broken { indent: self.indent, breaks: token.breaks });
|
||||
self.indent = match token.indent {
|
||||
IndentStyle::Block { offset } => (self.indent as isize + offset) as usize,
|
||||
IndentStyle::Visual => (self.margin - self.space) as usize,
|
||||
};
|
||||
} else {
|
||||
self.print_stack.push(PrintFrame::Fits);
|
||||
}
|
||||
}
|
||||
|
||||
fn print_end(&mut self) {
|
||||
self.print_stack.pop().unwrap();
|
||||
if let PrintFrame::Broken { indent, .. } = self.print_stack.pop().unwrap() {
|
||||
self.indent = indent;
|
||||
}
|
||||
}
|
||||
|
||||
fn print_break(&mut self, token: BreakToken, size: isize) {
|
||||
let break_offset =
|
||||
match self.get_top() {
|
||||
PrintFrame::Fits => None,
|
||||
PrintFrame::Broken { offset, breaks: Breaks::Consistent } => Some(offset),
|
||||
PrintFrame::Broken { offset, breaks: Breaks::Inconsistent } => {
|
||||
if size > self.space { Some(offset) } else { None }
|
||||
}
|
||||
};
|
||||
if let Some(offset) = break_offset {
|
||||
self.out.push('\n');
|
||||
self.pending_indentation = offset + token.offset;
|
||||
self.space = self.margin - (offset + token.offset);
|
||||
} else {
|
||||
let fits = match self.get_top() {
|
||||
PrintFrame::Fits => true,
|
||||
PrintFrame::Broken { breaks: Breaks::Consistent, .. } => false,
|
||||
PrintFrame::Broken { breaks: Breaks::Inconsistent, .. } => size <= self.space,
|
||||
};
|
||||
if fits {
|
||||
self.pending_indentation += token.blank_space;
|
||||
self.space -= token.blank_space;
|
||||
} else {
|
||||
self.out.push('\n');
|
||||
let indent = self.indent as isize + token.offset;
|
||||
self.pending_indentation = indent;
|
||||
self.space = self.margin - indent;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -422,7 +444,10 @@ impl Printer {
|
|||
|
||||
/// "raw box"
|
||||
pub fn rbox(&mut self, indent: usize, breaks: Breaks) {
|
||||
self.scan_begin(BeginToken { offset: indent as isize, breaks })
|
||||
self.scan_begin(BeginToken {
|
||||
indent: IndentStyle::Block { offset: indent as isize },
|
||||
breaks,
|
||||
})
|
||||
}
|
||||
|
||||
/// Inconsistent breaking box
|
||||
|
|
@ -435,6 +460,10 @@ impl Printer {
|
|||
self.rbox(indent, Breaks::Consistent)
|
||||
}
|
||||
|
||||
pub fn visual_align(&mut self) {
|
||||
self.scan_begin(BeginToken { indent: IndentStyle::Visual, breaks: Breaks::Consistent });
|
||||
}
|
||||
|
||||
pub fn break_offset(&mut self, n: usize, off: isize) {
|
||||
self.scan_break(BreakToken { offset: off, blank_space: n as isize })
|
||||
}
|
||||
|
|
|
|||
|
|
@ -315,7 +315,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
|
|||
self.word(cmnt.lines[0].clone());
|
||||
self.hardbreak()
|
||||
} else {
|
||||
self.ibox(0);
|
||||
self.visual_align();
|
||||
for line in &cmnt.lines {
|
||||
if !line.is_empty() {
|
||||
self.word(line.clone());
|
||||
|
|
@ -655,7 +655,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
|
|||
// Outer-box is consistent.
|
||||
self.cbox(INDENT_UNIT);
|
||||
// Head-box is inconsistent.
|
||||
self.ibox(w.len() + 1);
|
||||
self.ibox(0);
|
||||
// Keyword that starts the head.
|
||||
if !w.is_empty() {
|
||||
self.word_nbsp(w);
|
||||
|
|
|
|||
|
|
@ -320,7 +320,9 @@ impl<'a> State<'a> {
|
|||
self.print_ident(label.ident);
|
||||
self.word_space(":");
|
||||
}
|
||||
self.head("while");
|
||||
self.cbox(0);
|
||||
self.ibox(0);
|
||||
self.word_nbsp("while");
|
||||
self.print_expr_as_cond(test);
|
||||
self.space();
|
||||
self.print_block_with_attrs(blk, attrs);
|
||||
|
|
@ -330,7 +332,9 @@ impl<'a> State<'a> {
|
|||
self.print_ident(label.ident);
|
||||
self.word_space(":");
|
||||
}
|
||||
self.head("for");
|
||||
self.cbox(0);
|
||||
self.ibox(0);
|
||||
self.word_nbsp("for");
|
||||
self.print_pat(pat);
|
||||
self.space();
|
||||
self.word_space("in");
|
||||
|
|
@ -343,12 +347,14 @@ impl<'a> State<'a> {
|
|||
self.print_ident(label.ident);
|
||||
self.word_space(":");
|
||||
}
|
||||
self.head("loop");
|
||||
self.cbox(0);
|
||||
self.ibox(0);
|
||||
self.word_nbsp("loop");
|
||||
self.print_block_with_attrs(blk, attrs);
|
||||
}
|
||||
ast::ExprKind::Match(ref expr, ref arms) => {
|
||||
self.cbox(INDENT_UNIT);
|
||||
self.ibox(INDENT_UNIT);
|
||||
self.cbox(0);
|
||||
self.ibox(0);
|
||||
self.word_nbsp("match");
|
||||
self.print_expr_as_cond(expr);
|
||||
self.space();
|
||||
|
|
@ -388,7 +394,7 @@ impl<'a> State<'a> {
|
|||
self.word_space(":");
|
||||
}
|
||||
// containing cbox, will be closed by print-block at }
|
||||
self.cbox(INDENT_UNIT);
|
||||
self.cbox(0);
|
||||
// head-box, will be closed by print-block after {
|
||||
self.ibox(0);
|
||||
self.print_block_with_attrs(blk, attrs);
|
||||
|
|
@ -397,7 +403,7 @@ impl<'a> State<'a> {
|
|||
self.word_nbsp("async");
|
||||
self.print_capture_clause(capture_clause);
|
||||
// cbox/ibox in analogy to the `ExprKind::Block` arm above
|
||||
self.cbox(INDENT_UNIT);
|
||||
self.cbox(0);
|
||||
self.ibox(0);
|
||||
self.print_block_with_attrs(blk, attrs);
|
||||
}
|
||||
|
|
@ -500,7 +506,9 @@ impl<'a> State<'a> {
|
|||
self.word("?")
|
||||
}
|
||||
ast::ExprKind::TryBlock(ref blk) => {
|
||||
self.head("try");
|
||||
self.cbox(0);
|
||||
self.ibox(0);
|
||||
self.word_nbsp("try");
|
||||
self.print_block_with_attrs(blk, attrs)
|
||||
}
|
||||
ast::ExprKind::Err => {
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
use crate::pp::Breaks::Inconsistent;
|
||||
use crate::pprust::state::{AnnNode, PrintState, State, INDENT_UNIT};
|
||||
use crate::pprust::state::{AnnNode, PrintState, State};
|
||||
|
||||
use rustc_ast as ast;
|
||||
use rustc_ast::GenericBound;
|
||||
|
|
@ -377,7 +377,7 @@ impl<'a> State<'a> {
|
|||
self.space_if_not_bol();
|
||||
self.maybe_print_comment(v.span.lo());
|
||||
self.print_outer_attributes(&v.attrs);
|
||||
self.ibox(INDENT_UNIT);
|
||||
self.ibox(0);
|
||||
self.print_variant(v);
|
||||
self.word(",");
|
||||
self.end();
|
||||
|
|
|
|||
|
|
@ -28,67 +28,67 @@ fn syntax() {
|
|||
let _ = #[attr] (x as Y);
|
||||
let _ =
|
||||
#[attr] while true {
|
||||
#![attr]
|
||||
};
|
||||
#![attr]
|
||||
};
|
||||
let _ =
|
||||
#[attr] while let Some(false) = true {
|
||||
#![attr]
|
||||
};
|
||||
#![attr]
|
||||
};
|
||||
let _ =
|
||||
#[attr] for x in y {
|
||||
#![attr]
|
||||
};
|
||||
#![attr]
|
||||
};
|
||||
let _ =
|
||||
#[attr] loop {
|
||||
#![attr]
|
||||
};
|
||||
#![attr]
|
||||
};
|
||||
let _ =
|
||||
#[attr] match true {
|
||||
#![attr]
|
||||
#[attr]
|
||||
_ => false,
|
||||
};
|
||||
#![attr]
|
||||
#[attr]
|
||||
_ => false,
|
||||
};
|
||||
let _ = #[attr] || #[attr] foo;
|
||||
let _ = #[attr] move || #[attr] foo;
|
||||
let _ =
|
||||
#[attr] ||
|
||||
#[attr] {
|
||||
#![attr]
|
||||
foo
|
||||
};
|
||||
#[attr] {
|
||||
#![attr]
|
||||
foo
|
||||
};
|
||||
let _ =
|
||||
#[attr] move ||
|
||||
#[attr] {
|
||||
#![attr]
|
||||
foo
|
||||
};
|
||||
#[attr] {
|
||||
#![attr]
|
||||
foo
|
||||
};
|
||||
let _ =
|
||||
#[attr] ||
|
||||
{
|
||||
#![attr]
|
||||
foo
|
||||
};
|
||||
{
|
||||
#![attr]
|
||||
foo
|
||||
};
|
||||
let _ =
|
||||
#[attr] move ||
|
||||
{
|
||||
#![attr]
|
||||
foo
|
||||
};
|
||||
{
|
||||
#![attr]
|
||||
foo
|
||||
};
|
||||
let _ =
|
||||
#[attr] {
|
||||
#![attr]
|
||||
};
|
||||
#![attr]
|
||||
};
|
||||
let _ =
|
||||
#[attr] {
|
||||
#![attr]
|
||||
let _ = ();
|
||||
};
|
||||
#![attr]
|
||||
let _ = ();
|
||||
};
|
||||
let _ =
|
||||
#[attr] {
|
||||
#![attr]
|
||||
let _ = ();
|
||||
foo
|
||||
};
|
||||
#![attr]
|
||||
let _ = ();
|
||||
foo
|
||||
};
|
||||
let _ = #[attr] x = y;
|
||||
let _ = #[attr] (x = y);
|
||||
let _ = #[attr] x += y;
|
||||
|
|
|
|||
|
|
@ -93,9 +93,9 @@ fn main() {
|
|||
// Taken from https://www.unicode.org/Public/UNIDATA/PropList.txt
|
||||
let chars =
|
||||
['\x0A', '\x0B', '\x0C', '\x0D', '\x20', '\u{85}', '\u{A0}',
|
||||
'\u{1680}', '\u{2000}', '\u{2001}', '\u{2002}', '\u{2003}',
|
||||
'\u{2004}', '\u{2005}', '\u{2006}', '\u{2007}', '\u{2008}',
|
||||
'\u{2009}', '\u{200A}', '\u{2028}', '\u{2029}', '\u{202F}',
|
||||
'\u{205F}', '\u{3000}'];
|
||||
'\u{1680}', '\u{2000}', '\u{2001}', '\u{2002}', '\u{2003}',
|
||||
'\u{2004}', '\u{2005}', '\u{2006}', '\u{2007}', '\u{2008}',
|
||||
'\u{2009}', '\u{200A}', '\u{2028}', '\u{2029}', '\u{202F}',
|
||||
'\u{205F}', '\u{3000}'];
|
||||
for c in &chars { let ws = c.is_whitespace(); println!("{} {}", c, ws); }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,9 +17,9 @@ mac! {
|
|||
|
||||
mac! {
|
||||
a(aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa
|
||||
aaaaaaaa aaaaaaaa) a
|
||||
aaaaaaaa aaaaaaaa) a
|
||||
[aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa
|
||||
aaaaaaaa aaaaaaaa] a
|
||||
aaaaaaaa aaaaaaaa] a
|
||||
{
|
||||
aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa
|
||||
aaaaaaaa aaaaaaaa aaaaaaaa
|
||||
|
|
@ -27,22 +27,22 @@ mac! {
|
|||
}
|
||||
|
||||
mac!(aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa
|
||||
aaaaaaaa aaaaaaaa);
|
||||
aaaaaaaa aaaaaaaa);
|
||||
mac![aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa
|
||||
aaaaaaaa aaaaaaaa];
|
||||
aaaaaaaa aaaaaaaa];
|
||||
mac! {
|
||||
aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa
|
||||
aaaaaaaa aaaaaaaa
|
||||
}
|
||||
|
||||
#[rustc_dummy(aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa
|
||||
aaaaaaaa aaaaaaaa aaaaaaaa)]
|
||||
aaaaaaaa aaaaaaaa aaaaaaaa)]
|
||||
#[rustc_dummy[aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa
|
||||
aaaaaaaa aaaaaaaa aaaaaaaa]]
|
||||
aaaaaaaa aaaaaaaa aaaaaaaa]]
|
||||
#[rustc_dummy {
|
||||
aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa
|
||||
aaaaaaaa aaaaaaaa
|
||||
}]
|
||||
aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa
|
||||
aaaaaaaa aaaaaaaa
|
||||
}]
|
||||
#[rustc_dummy =
|
||||
"aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa"]
|
||||
"aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa aaaaaaaa"]
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -11,15 +11,15 @@ extern crate std;
|
|||
pub fn foo(_: [i32; (3 as usize)]) ({ } as ())
|
||||
|
||||
pub fn bar() ({
|
||||
const FOO: usize = ((5 as usize) - (4 as usize) as usize);
|
||||
let _: [(); (FOO as usize)] = ([(() as ())] as [(); 1]);
|
||||
const FOO: usize = ((5 as usize) - (4 as usize) as usize);
|
||||
let _: [(); (FOO as usize)] = ([(() as ())] as [(); 1]);
|
||||
|
||||
let _: [(); (1 as usize)] = ([(() as ())] as [(); 1]);
|
||||
let _: [(); (1 as usize)] = ([(() as ())] as [(); 1]);
|
||||
|
||||
let _ =
|
||||
(((&([(1 as i32), (2 as i32), (3 as i32)] as [i32; 3])
|
||||
as &[i32; 3]) as *const _ as *const [i32; 3]) as
|
||||
*const [i32; (3 as usize)] as *const [i32; 3]);
|
||||
let _ =
|
||||
(((&([(1 as i32), (2 as i32), (3 as i32)] as [i32; 3]) as
|
||||
&[i32; 3]) as *const _ as *const [i32; 3]) as
|
||||
*const [i32; (3 as usize)] as *const [i32; 3]);
|
||||
|
||||
|
||||
|
||||
|
|
@ -29,29 +29,19 @@ pub fn bar() ({
|
|||
|
||||
|
||||
|
||||
({
|
||||
let res =
|
||||
((::alloc::fmt::format as
|
||||
for<'r> fn(Arguments<'r>) -> String {format})(((::core::fmt::Arguments::new_v1
|
||||
as
|
||||
fn(&[&'static str], &[ArgumentV1]) -> Arguments {Arguments::new_v1})((&([("test"
|
||||
as
|
||||
&str)]
|
||||
as
|
||||
[&str; 1])
|
||||
as
|
||||
&[&str; 1]),
|
||||
(&([]
|
||||
as
|
||||
[ArgumentV1; 0])
|
||||
as
|
||||
&[ArgumentV1; 0]))
|
||||
as
|
||||
Arguments))
|
||||
as String);
|
||||
(res as String)
|
||||
} as String);
|
||||
} as ())
|
||||
({
|
||||
let res =
|
||||
((::alloc::fmt::format as
|
||||
for<'r> fn(Arguments<'r>) -> String {format})(((::core::fmt::Arguments::new_v1
|
||||
as
|
||||
fn(&[&'static str], &[ArgumentV1]) -> Arguments {Arguments::new_v1})((&([("test"
|
||||
as &str)] as [&str; 1]) as
|
||||
&[&str; 1]),
|
||||
(&([] as [ArgumentV1; 0]) as &[ArgumentV1; 0])) as
|
||||
Arguments)) as String);
|
||||
(res as String)
|
||||
} as String);
|
||||
} as ())
|
||||
pub type Foo = [i32; (3 as usize)];
|
||||
pub struct Bar {
|
||||
pub x: [i32; (3 as usize)],
|
||||
|
|
@ -60,19 +50,9 @@ pub struct TupleBar([i32; (4 as usize)]);
|
|||
pub enum Baz { BazVariant([i32; (5 as usize)]), }
|
||||
pub fn id<T>(x: T) -> T ({ (x as T) } as T)
|
||||
pub fn use_id() ({
|
||||
let _ =
|
||||
((id::<[i32; (3 as usize)]> as
|
||||
fn([i32; 3]) -> [i32; 3] {id::<[i32; 3]>})(([(1
|
||||
as
|
||||
i32),
|
||||
(2
|
||||
as
|
||||
i32),
|
||||
(3
|
||||
as
|
||||
i32)]
|
||||
as
|
||||
[i32; 3]))
|
||||
as [i32; 3]);
|
||||
} as ())
|
||||
let _ =
|
||||
((id::<[i32; (3 as usize)]> as
|
||||
fn([i32; 3]) -> [i32; 3] {id::<[i32; 3]>})(([(1 as i32),
|
||||
(2 as i32), (3 as i32)] as [i32; 3])) as [i32; 3]);
|
||||
} as ())
|
||||
fn main() ({ } as ())
|
||||
|
|
|
|||
|
|
@ -9,8 +9,8 @@ struct C {
|
|||
#[allow()]
|
||||
const C: C =
|
||||
C{
|
||||
#[cfg(debug_assertions)]
|
||||
field: 0,
|
||||
#[cfg(debug_assertions)]
|
||||
field: 0,
|
||||
|
||||
#[cfg(not(debug_assertions))]
|
||||
field: 1,};
|
||||
#[cfg(not(debug_assertions))]
|
||||
field: 1,};
|
||||
|
|
|
|||
|
|
@ -12,8 +12,8 @@ macro_rules! matcher_brackets {
|
|||
|
||||
macro_rules! all_fragments {
|
||||
($b : block, $e : expr, $i : ident, $it : item, $l : lifetime, $lit :
|
||||
literal, $m : meta, $p : pat, $pth : path, $s : stmt, $tt : tt, $ty : ty,
|
||||
$vis : vis) => {} ;
|
||||
literal, $m : meta, $p : pat, $pth : path, $s : stmt, $tt : tt, $ty : ty,
|
||||
$vis : vis) => {} ;
|
||||
}
|
||||
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -5,10 +5,10 @@ fn main() {
|
|||
let _y =
|
||||
match x {
|
||||
Some(_) =>
|
||||
["some(_)".to_string(), "not".to_string(), "SO".to_string(),
|
||||
"long".to_string(), "string".to_string()],
|
||||
["some(_)".to_string(), "not".to_string(), "SO".to_string(),
|
||||
"long".to_string(), "string".to_string()],
|
||||
None =>
|
||||
["none".to_string(), "a".to_string(), "a".to_string(),
|
||||
"a".to_string(), "a".to_string()],
|
||||
["none".to_string(), "a".to_string(), "a".to_string(),
|
||||
"a".to_string(), "a".to_string()],
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -48,9 +48,9 @@ fn _4() {
|
|||
|
||||
let _ =
|
||||
#[rustc_dummy] match () {
|
||||
#![rustc_dummy]
|
||||
() => (),
|
||||
};
|
||||
#![rustc_dummy]
|
||||
() => (),
|
||||
};
|
||||
}
|
||||
|
||||
fn _5() {
|
||||
|
|
@ -156,56 +156,56 @@ fn _11() {
|
|||
let _ = #[rustc_dummy] 0 as usize;
|
||||
let _ =
|
||||
#[rustc_dummy] while false {
|
||||
#![rustc_dummy]
|
||||
};
|
||||
#![rustc_dummy]
|
||||
};
|
||||
let _ =
|
||||
#[rustc_dummy] while let None = Some(()) {
|
||||
#![rustc_dummy]
|
||||
};
|
||||
#![rustc_dummy]
|
||||
};
|
||||
let _ =
|
||||
#[rustc_dummy] for _ in 0..0 {
|
||||
#![rustc_dummy]
|
||||
};
|
||||
#![rustc_dummy]
|
||||
};
|
||||
let _ =
|
||||
#[rustc_dummy] loop {
|
||||
#![rustc_dummy]
|
||||
};
|
||||
#![rustc_dummy]
|
||||
};
|
||||
let _ =
|
||||
#[rustc_dummy] match false {
|
||||
#![rustc_dummy]
|
||||
_ => (),
|
||||
};
|
||||
#![rustc_dummy]
|
||||
_ => (),
|
||||
};
|
||||
let _ = #[rustc_dummy] || #[rustc_dummy] ();
|
||||
let _ = #[rustc_dummy] move || #[rustc_dummy] ();
|
||||
let _ =
|
||||
#[rustc_dummy] ||
|
||||
{
|
||||
#![rustc_dummy]
|
||||
#[rustc_dummy]
|
||||
()
|
||||
};
|
||||
{
|
||||
#![rustc_dummy]
|
||||
#[rustc_dummy]
|
||||
()
|
||||
};
|
||||
let _ =
|
||||
#[rustc_dummy] move ||
|
||||
{
|
||||
#![rustc_dummy]
|
||||
#[rustc_dummy]
|
||||
()
|
||||
};
|
||||
{
|
||||
#![rustc_dummy]
|
||||
#[rustc_dummy]
|
||||
()
|
||||
};
|
||||
let _ =
|
||||
#[rustc_dummy] {
|
||||
#![rustc_dummy]
|
||||
};
|
||||
#![rustc_dummy]
|
||||
};
|
||||
let _ =
|
||||
#[rustc_dummy] {
|
||||
#![rustc_dummy]
|
||||
let _ = ();
|
||||
};
|
||||
#![rustc_dummy]
|
||||
let _ = ();
|
||||
};
|
||||
let _ =
|
||||
#[rustc_dummy] {
|
||||
#![rustc_dummy]
|
||||
let _ = ();
|
||||
()
|
||||
};
|
||||
#![rustc_dummy]
|
||||
let _ = ();
|
||||
()
|
||||
};
|
||||
let mut x = 0;
|
||||
let _ = #[rustc_dummy] x = 15;
|
||||
let _ = #[rustc_dummy] x += 15;
|
||||
|
|
|
|||
|
|
@ -4,26 +4,26 @@
|
|||
fn main() {
|
||||
let _v1 =
|
||||
[
|
||||
// Comment
|
||||
0,
|
||||
// Comment
|
||||
1,
|
||||
// Comment
|
||||
2];
|
||||
// Comment
|
||||
0,
|
||||
// Comment
|
||||
1,
|
||||
// Comment
|
||||
2];
|
||||
let _v2 =
|
||||
[0, // Comment
|
||||
1, // Comment
|
||||
2]; // Comment
|
||||
1, // Comment
|
||||
2]; // Comment
|
||||
let _v3 =
|
||||
[
|
||||
/* Comment */
|
||||
0,
|
||||
/* Comment */
|
||||
1,
|
||||
/* Comment */
|
||||
2];
|
||||
/* Comment */
|
||||
0,
|
||||
/* Comment */
|
||||
1,
|
||||
/* Comment */
|
||||
2];
|
||||
let _v4 =
|
||||
[0, /* Comment */
|
||||
1, /* Comment */
|
||||
2]; /* Comment */
|
||||
1, /* Comment */
|
||||
2]; /* Comment */
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,11 +16,11 @@ LL | bug!();
|
|||
= note: this error originates in the macro `bug` (in Nightly builds, run with -Z macro-backtrace for more info)
|
||||
|
||||
error: unexpected token: `{
|
||||
let res =
|
||||
::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""],
|
||||
&[::core::fmt::ArgumentV1::new_display(&"u8")]));
|
||||
res
|
||||
}.as_str()`
|
||||
let res =
|
||||
::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""],
|
||||
&[::core::fmt::ArgumentV1::new_display(&"u8")]));
|
||||
res
|
||||
}.as_str()`
|
||||
--> $DIR/key-value-expansion.rs:48:23
|
||||
|
|
||||
LL | doc_comment! {format!("{coor}", coor = stringify!($t1)).as_str()}
|
||||
|
|
|
|||
|
|
@ -15,4 +15,4 @@ trait Foo<const KIND : bool = true> {}
|
|||
fn foo<const SIZE : usize = 5>() {}
|
||||
|
||||
struct Range<const FROM : usize = 0, const LEN : usize = 0, const TO : usize =
|
||||
FROM>;
|
||||
FROM>;
|
||||
|
|
|
|||
|
|
@ -7,13 +7,11 @@ extern crate std;
|
|||
// check-pass
|
||||
|
||||
pub fn main() ({
|
||||
(if (true as bool)
|
||||
({ } as
|
||||
()) else if (let Some(a) =
|
||||
((Some as
|
||||
fn(i32) -> Option<i32> {Option::<i32>::Some})((3
|
||||
as
|
||||
i32))
|
||||
as Option<i32>) as bool)
|
||||
({ } as ()) as ())
|
||||
} as ())
|
||||
(if (true as bool)
|
||||
({ } as
|
||||
()) else if (let Some(a) =
|
||||
((Some as
|
||||
fn(i32) -> Option<i32> {Option::<i32>::Some})((3
|
||||
as i32)) as Option<i32>) as bool) ({ } as ())
|
||||
as ())
|
||||
} as ())
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
PRINT-ATTR INPUT (DISPLAY): impl Foo <
|
||||
[u8 ;
|
||||
{
|
||||
#! [rustc_dummy(cursed_inner)] #! [allow(unused)] struct Inner
|
||||
{ field : [u8 ; { #! [rustc_dummy(another_cursed_inner)] 1 }] } 0
|
||||
}] > { #! [rustc_dummy(evaluated_attr)] fn bar() {} }
|
||||
{
|
||||
#! [rustc_dummy(cursed_inner)] #! [allow(unused)] struct Inner
|
||||
{ field : [u8 ; { #! [rustc_dummy(another_cursed_inner)] 1 }] } 0
|
||||
}] > { #! [rustc_dummy(evaluated_attr)] fn bar() {} }
|
||||
PRINT-ATTR INPUT (DEBUG): TokenStream [
|
||||
Ident {
|
||||
ident: "impl",
|
||||
|
|
|
|||
|
|
@ -4,23 +4,23 @@ struct Foo < #[cfg(FALSE)] A, B >
|
|||
#[cfg(FALSE)] first : String, #[cfg_attr(FALSE, deny(warnings))] second :
|
||||
bool, third :
|
||||
[u8 ;
|
||||
{
|
||||
#[cfg(FALSE)] struct Bar ; #[cfg(not(FALSE))] struct Inner ;
|
||||
#[cfg(FALSE)] let a = 25 ; match true
|
||||
{
|
||||
#[cfg(FALSE)] true => {},
|
||||
#[cfg_attr(not(FALSE), allow(warnings))] false => {}, _ => {}
|
||||
} ; #[print_helper(should_be_removed)] fn removed_fn()
|
||||
{ #! [cfg(FALSE)] } #[print_helper(c)] #[cfg(not(FALSE))] fn
|
||||
kept_fn() { #! [cfg(not(FALSE))] let my_val = true ; } enum TupleEnum
|
||||
{
|
||||
Foo(#[cfg(FALSE)] u8, #[cfg(FALSE)] bool, #[cfg(not(FALSE))] i32,
|
||||
#[cfg(FALSE)] String, u8)
|
||||
} struct
|
||||
TupleStruct(#[cfg(FALSE)] String, #[cfg(not(FALSE))] i32,
|
||||
#[cfg(FALSE)] bool, u8) ; fn plain_removed_fn()
|
||||
{ #! [cfg_attr(not(FALSE), cfg(FALSE))] } 0
|
||||
}], #[print_helper(d)] fourth : B
|
||||
{
|
||||
#[cfg(FALSE)] struct Bar ; #[cfg(not(FALSE))] struct Inner ;
|
||||
#[cfg(FALSE)] let a = 25 ; match true
|
||||
{
|
||||
#[cfg(FALSE)] true => {}, #[cfg_attr(not(FALSE), allow(warnings))]
|
||||
false => {}, _ => {}
|
||||
} ; #[print_helper(should_be_removed)] fn removed_fn()
|
||||
{ #! [cfg(FALSE)] } #[print_helper(c)] #[cfg(not(FALSE))] fn kept_fn()
|
||||
{ #! [cfg(not(FALSE))] let my_val = true ; } enum TupleEnum
|
||||
{
|
||||
Foo(#[cfg(FALSE)] u8, #[cfg(FALSE)] bool, #[cfg(not(FALSE))] i32,
|
||||
#[cfg(FALSE)] String, u8)
|
||||
} struct
|
||||
TupleStruct(#[cfg(FALSE)] String, #[cfg(not(FALSE))] i32,
|
||||
#[cfg(FALSE)] bool, u8) ; fn plain_removed_fn()
|
||||
{ #! [cfg_attr(not(FALSE), cfg(FALSE))] } 0
|
||||
}], #[print_helper(d)] fourth : B
|
||||
}
|
||||
PRINT-ATTR INPUT (DEBUG): TokenStream [
|
||||
Punct {
|
||||
|
|
@ -1276,14 +1276,14 @@ PRINT-DERIVE INPUT (DISPLAY): #[print_helper(a)] #[allow(dead_code)] #[print_hel
|
|||
{
|
||||
second : bool, third :
|
||||
[u8 ;
|
||||
{
|
||||
#[cfg(not(FALSE))] struct Inner ; match true
|
||||
{ #[allow(warnings)] false => {}, _ => {} } ; #[print_helper(c)]
|
||||
#[cfg(not(FALSE))] fn kept_fn()
|
||||
{ #! [cfg(not(FALSE))] let my_val = true ; } enum TupleEnum
|
||||
{ Foo(#[cfg(not(FALSE))] i32, u8) } struct
|
||||
TupleStruct(#[cfg(not(FALSE))] i32, u8) ; 0
|
||||
}], #[print_helper(d)] fourth : B
|
||||
{
|
||||
#[cfg(not(FALSE))] struct Inner ; match true
|
||||
{ #[allow(warnings)] false => {}, _ => {} } ; #[print_helper(c)]
|
||||
#[cfg(not(FALSE))] fn kept_fn()
|
||||
{ #! [cfg(not(FALSE))] let my_val = true ; } enum TupleEnum
|
||||
{ Foo(#[cfg(not(FALSE))] i32, u8) } struct
|
||||
TupleStruct(#[cfg(not(FALSE))] i32, u8) ; 0
|
||||
}], #[print_helper(d)] fourth : B
|
||||
}
|
||||
PRINT-DERIVE INPUT (DEBUG): TokenStream [
|
||||
Punct {
|
||||
|
|
|
|||
|
|
@ -2,10 +2,10 @@ PRINT-DERIVE INPUT (DISPLAY): struct Foo
|
|||
{
|
||||
val :
|
||||
[bool ;
|
||||
{
|
||||
let a = #[rustc_dummy(first)] #[rustc_dummy(second)]
|
||||
{ #! [allow(unused)] 30 } ; 0
|
||||
}]
|
||||
{
|
||||
let a = #[rustc_dummy(first)] #[rustc_dummy(second)]
|
||||
{ #! [allow(unused)] 30 } ; 0
|
||||
}]
|
||||
}
|
||||
PRINT-DERIVE INPUT (DEBUG): TokenStream [
|
||||
Ident {
|
||||
|
|
|
|||
|
|
@ -19,29 +19,27 @@ extern crate proc_macro;
|
|||
|
||||
fn main() {
|
||||
[crate::TokenStream::from(crate::TokenTree::Ident(crate::Ident::new("let",
|
||||
crate::Span::recover_proc_macro_span(0)))),
|
||||
crate::TokenStream::from(crate::TokenTree::Ident(crate::Ident::new("hello",
|
||||
crate::Span::recover_proc_macro_span(1)))),
|
||||
crate::TokenStream::from(crate::TokenTree::Punct(crate::Punct::new('\u{3d}',
|
||||
crate::Spacing::Alone))),
|
||||
crate::TokenStream::from(crate::TokenTree::Literal({
|
||||
let mut iter =
|
||||
"\"world\"".parse::<crate::TokenStream>().unwrap().into_iter();
|
||||
if let (Some(crate::TokenTree::Literal(mut lit)),
|
||||
None) =
|
||||
(iter.next(),
|
||||
iter.next())
|
||||
{
|
||||
lit.set_span(crate::Span::recover_proc_macro_span(2));
|
||||
lit
|
||||
} else {
|
||||
{
|
||||
::core::panicking::panic("internal error: entered unreachable code")
|
||||
}
|
||||
}
|
||||
})),
|
||||
crate::TokenStream::from(crate::TokenTree::Punct(crate::Punct::new('\u{3b}',
|
||||
crate::Spacing::Alone)))].iter().cloned().collect::<crate::TokenStream>()
|
||||
crate::Span::recover_proc_macro_span(0)))),
|
||||
crate::TokenStream::from(crate::TokenTree::Ident(crate::Ident::new("hello",
|
||||
crate::Span::recover_proc_macro_span(1)))),
|
||||
crate::TokenStream::from(crate::TokenTree::Punct(crate::Punct::new('\u{3d}',
|
||||
crate::Spacing::Alone))),
|
||||
crate::TokenStream::from(crate::TokenTree::Literal({
|
||||
let mut iter =
|
||||
"\"world\"".parse::<crate::TokenStream>().unwrap().into_iter();
|
||||
if let (Some(crate::TokenTree::Literal(mut lit)),
|
||||
None) =
|
||||
(iter.next(), iter.next()) {
|
||||
lit.set_span(crate::Span::recover_proc_macro_span(2));
|
||||
lit
|
||||
} else {
|
||||
{
|
||||
::core::panicking::panic("internal error: entered unreachable code")
|
||||
}
|
||||
}
|
||||
})),
|
||||
crate::TokenStream::from(crate::TokenTree::Punct(crate::Punct::new('\u{3b}',
|
||||
crate::Spacing::Alone)))].iter().cloned().collect::<crate::TokenStream>()
|
||||
}
|
||||
const _: () =
|
||||
{
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ checker!(rename_params, r#"impl Foo
|
|||
fn hello(#[angery(true)] a : i32, #[a2] b : i32, #[what = "how"] c : u32)
|
||||
{} fn
|
||||
hello2(#[a1] #[a2] a : i32, #[what = "how"] b : i32, #[angery(true)] c :
|
||||
u32) {} fn
|
||||
u32) {} fn
|
||||
hello_self(#[a1] #[a2] & self, #[a1] #[a2] a : i32, #[what = "how"] b :
|
||||
i32, #[angery(true)] c : u32) {}
|
||||
i32, #[angery(true)] c : u32) {}
|
||||
}"#);
|
||||
|
|
|
|||
|
|
@ -10,5 +10,5 @@ extern crate std;
|
|||
trait Animal { }
|
||||
|
||||
fn main() {
|
||||
pub type ServeFut = /*impl Trait*/;
|
||||
}
|
||||
pub type ServeFut = /*impl Trait*/;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue