579 lines
15 KiB
Rust
579 lines
15 KiB
Rust
// rustfmt-normalize_comments: true
|
|
// Match expressions.
|
|
|
|
fn foo() {
|
|
// A match expression.
|
|
match x {
|
|
// Some comment.
|
|
a => foo(),
|
|
b if 0 < 42 => foo(),
|
|
c => {
|
|
// Another comment.
|
|
// Comment.
|
|
an_expression;
|
|
foo()
|
|
}
|
|
Foo(ref bar) => {
|
|
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
|
|
}
|
|
Pattern1 | Pattern2 | Pattern3 => false,
|
|
Paternnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
|
|
| Paternnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn => blah,
|
|
Patternnnnnnnnnnnnnnnnnnn
|
|
| Patternnnnnnnnnnnnnnnnnnn
|
|
| Patternnnnnnnnnnnnnnnnnnn
|
|
| Patternnnnnnnnnnnnnnnnnnn => meh,
|
|
|
|
Patternnnnnnnnnnnnnnnnnnn | Patternnnnnnnnnnnnnnnnnnn if looooooooooooooooooong_guard => {
|
|
meh
|
|
}
|
|
|
|
Patternnnnnnnnnnnnnnnnnnnnnnnnn | Patternnnnnnnnnnnnnnnnnnnnnnnnn
|
|
if looooooooooooooooooooooooooooooooooooooooong_guard =>
|
|
{
|
|
meh
|
|
}
|
|
|
|
// Test that earlier patterns can take the guard space
|
|
(aaaa, bbbbb, ccccccc, aaaaa, bbbbbbbb, cccccc, aaaa, bbbbbbbb, cccccc, dddddd)
|
|
| Patternnnnnnnnnnnnnnnnnnnnnnnnn
|
|
if loooooooooooooooooooooooooooooooooooooooooong_guard => {}
|
|
|
|
_ => {}
|
|
ast::PathParameters::AngleBracketedParameters(ref data)
|
|
if data.lifetimes.len() > 0 || data.types.len() > 0 || data.bindings.len() > 0 => {}
|
|
}
|
|
|
|
let whatever = match something {
|
|
/// DOC COMMENT!
|
|
Some(_) => 42,
|
|
// Comment on an attribute.
|
|
#[an_attribute]
|
|
// Comment after an attribute.
|
|
None => 0,
|
|
#[rustfmt::skip]
|
|
Blurb => { }
|
|
};
|
|
}
|
|
|
|
// Test that a match on an overflow line is laid out properly.
|
|
fn main() {
|
|
let sub_span =
|
|
match xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx {
|
|
Some(sub_span) => Some(sub_span),
|
|
None => sub_span,
|
|
};
|
|
}
|
|
|
|
// Test that one-line bodies align.
|
|
fn main() {
|
|
match r {
|
|
Variableeeeeeeeeeeeeeeeee => (
|
|
"variable",
|
|
vec!["id", "name", "qualname", "value", "type", "scopeid"],
|
|
true,
|
|
true,
|
|
),
|
|
Enummmmmmmmmmmmmmmmmmmmm => (
|
|
"enum",
|
|
vec!["id", "qualname", "scopeid", "value"],
|
|
true,
|
|
true,
|
|
),
|
|
Variantttttttttttttttttttttttt => (
|
|
"variant",
|
|
vec!["id", "name", "qualname", "type", "value", "scopeid"],
|
|
true,
|
|
true,
|
|
),
|
|
};
|
|
|
|
match x {
|
|
y => { /*Block with comment. Preserve me.*/ }
|
|
z => {
|
|
stmt();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn matches() {
|
|
match 1 {
|
|
-1 => 10,
|
|
1 => 1, // foo
|
|
2 => 2,
|
|
// bar
|
|
3 => 3,
|
|
_ => 0, // baz
|
|
}
|
|
}
|
|
|
|
fn match_skip() {
|
|
let _ = match Some(1) {
|
|
#[rustfmt::skip]
|
|
Some( n ) => n,
|
|
None => 1,
|
|
};
|
|
}
|
|
|
|
fn issue339() {
|
|
match a {
|
|
b => {}
|
|
c => {}
|
|
d => {}
|
|
e => {}
|
|
// collapsing here is safe
|
|
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff => {}
|
|
// collapsing here exceeds line length
|
|
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffg => {
|
|
}
|
|
h => {
|
|
// comment above block
|
|
}
|
|
i => {} // comment below block
|
|
j => {
|
|
// comment inside block
|
|
}
|
|
j2 => {
|
|
// comments inside...
|
|
} // ... and after
|
|
// TODO uncomment when vertical whitespace is handled better
|
|
// k => {
|
|
//
|
|
// // comment with WS above
|
|
// }
|
|
// l => {
|
|
// // comment with ws below
|
|
//
|
|
// }
|
|
m => {}
|
|
n => {}
|
|
o => {}
|
|
p => {
|
|
// Don't collapse me
|
|
}
|
|
q => {}
|
|
r => {}
|
|
s => 0, // s comment
|
|
// t comment
|
|
t => 1,
|
|
u => 2,
|
|
v => {} /* funky block
|
|
* comment */
|
|
/* final comment */
|
|
}
|
|
}
|
|
|
|
fn issue355() {
|
|
match mac {
|
|
a => println!("a", b),
|
|
b => vec![1, 2],
|
|
c => vec![3; 4],
|
|
d => println!("a", b),
|
|
e => vec![1, 2],
|
|
f => vec![3; 4],
|
|
h => println!("a", b), // h comment
|
|
i => vec![1, 2], // i comment
|
|
j => vec![3; 4], // j comment
|
|
// k comment
|
|
k => println!("a", b),
|
|
// l comment
|
|
l => vec![1, 2],
|
|
// m comment
|
|
m => vec![3; 4],
|
|
// Rewrite splits macro
|
|
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn => {
|
|
println!("a", b)
|
|
}
|
|
// Rewrite splits macro
|
|
oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo => {
|
|
vec![1, 2]
|
|
}
|
|
// Macro support fails to recognise this macro as splittable
|
|
// We push the whole expr to a new line, TODO split this macro as well
|
|
pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp => {
|
|
vec![3; 4]
|
|
}
|
|
// q, r and s: Rewrite splits match arm
|
|
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq => {
|
|
println!("a", b)
|
|
}
|
|
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr => {
|
|
vec![1, 2]
|
|
}
|
|
ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss => {
|
|
vec![3; 4]
|
|
}
|
|
// Funky bracketing styles
|
|
t => println! {"a", b},
|
|
u => vec![1, 2],
|
|
v => vec![3; 4],
|
|
w => println!["a", b],
|
|
x => vec![1, 2],
|
|
y => vec![3; 4],
|
|
// Brackets with comments
|
|
tc => println! {"a", b}, // comment
|
|
uc => vec![1, 2], // comment
|
|
vc => vec![3; 4], // comment
|
|
wc => println!["a", b], // comment
|
|
xc => vec![1, 2], // comment
|
|
yc => vec![3; 4], // comment
|
|
yd => looooooooooooooooooooooooooooooooooooooooooooooooooooooooong_func(
|
|
aaaaaaaaaa, bbbbbbbbbb, cccccccccc, dddddddddd,
|
|
),
|
|
}
|
|
}
|
|
|
|
fn issue280() {
|
|
{
|
|
match x {
|
|
CompressionMode::DiscardNewline | CompressionMode::CompressWhitespaceNewline => {
|
|
ch == '\n'
|
|
}
|
|
ast::ItemConst(ref typ, ref expr) => {
|
|
self.process_static_or_const_item(item, &typ, &expr)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn issue383() {
|
|
match resolution.last_private {
|
|
LastImport { .. } => false,
|
|
_ => true,
|
|
};
|
|
}
|
|
|
|
fn issue507() {
|
|
match 1 {
|
|
1 => unsafe { std::intrinsics::abort() },
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
fn issue508() {
|
|
match s.type_id() {
|
|
Some(NodeTypeId::Element(ElementTypeId::HTMLElement(
|
|
HTMLElementTypeId::HTMLCanvasElement,
|
|
))) => true,
|
|
Some(NodeTypeId::Element(ElementTypeId::HTMLElement(
|
|
HTMLElementTypeId::HTMLObjectElement,
|
|
))) => s.has_object_data(),
|
|
Some(NodeTypeId::Element(_)) => false,
|
|
}
|
|
}
|
|
|
|
fn issue496() {
|
|
{
|
|
{
|
|
{
|
|
match def {
|
|
def::DefConst(def_id) | def::DefAssociatedConst(def_id) => {
|
|
match const_eval::lookup_const_by_id(cx.tcx, def_id, Some(self.pat.id)) {
|
|
Some(const_expr) => x,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn issue494() {
|
|
{
|
|
match stmt.node {
|
|
hir::StmtExpr(ref expr, id) | hir::StmtSemi(ref expr, id) => {
|
|
result.push(StmtRef::Mirror(Box::new(Stmt {
|
|
span: stmt.span,
|
|
kind: StmtKind::Expr {
|
|
scope: cx.tcx.region_maps.node_extent(id),
|
|
expr: expr.to_ref(),
|
|
},
|
|
})))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn issue386() {
|
|
match foo {
|
|
BiEq | BiLt | BiLe | BiNe | BiGt | BiGe => true,
|
|
BiAnd | BiOr | BiAdd | BiSub | BiMul | BiDiv | BiRem | BiBitXor | BiBitAnd | BiBitOr
|
|
| BiShl | BiShr => false,
|
|
}
|
|
}
|
|
|
|
fn guards() {
|
|
match foo {
|
|
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
|
|
if foooooooooooooo && barrrrrrrrrrrr => {}
|
|
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
|
|
| aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
|
|
if foooooooooooooo && barrrrrrrrrrrr => {}
|
|
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
|
|
if fooooooooooooooooooooo
|
|
&& (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
|
|
|| cccccccccccccccccccccccccccccccccccccccc) => {}
|
|
}
|
|
}
|
|
|
|
fn issue1371() {
|
|
Some(match type_ {
|
|
sfEvtClosed => Closed,
|
|
sfEvtResized => {
|
|
let e = unsafe { *event.size.as_ref() };
|
|
|
|
Resized {
|
|
width: e.width,
|
|
height: e.height,
|
|
}
|
|
}
|
|
sfEvtLostFocus => LostFocus,
|
|
sfEvtGainedFocus => GainedFocus,
|
|
sfEvtTextEntered => TextEntered {
|
|
unicode: unsafe {
|
|
::std::char::from_u32((*event.text.as_ref()).unicode)
|
|
.expect("Invalid unicode encountered on TextEntered event")
|
|
},
|
|
},
|
|
sfEvtKeyPressed => {
|
|
let e = unsafe { event.key.as_ref() };
|
|
|
|
KeyPressed {
|
|
code: unsafe { ::std::mem::transmute(e.code) },
|
|
alt: e.alt.to_bool(),
|
|
ctrl: e.control.to_bool(),
|
|
shift: e.shift.to_bool(),
|
|
system: e.system.to_bool(),
|
|
}
|
|
}
|
|
sfEvtKeyReleased => {
|
|
let e = unsafe { event.key.as_ref() };
|
|
|
|
KeyReleased {
|
|
code: unsafe { ::std::mem::transmute(e.code) },
|
|
alt: e.alt.to_bool(),
|
|
ctrl: e.control.to_bool(),
|
|
shift: e.shift.to_bool(),
|
|
system: e.system.to_bool(),
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
fn issue1395() {
|
|
let bar = Some(true);
|
|
let foo = Some(true);
|
|
let mut x = false;
|
|
bar.and_then(|_| match foo {
|
|
None => None,
|
|
Some(b) => {
|
|
x = true;
|
|
Some(b)
|
|
}
|
|
});
|
|
}
|
|
|
|
fn issue1456() {
|
|
Ok(Recording {
|
|
artists: match reader.evaluate(".//mb:recording/mb:artist-credit/mb:name-credit")? {
|
|
Nodeset(nodeset) => {
|
|
let res: Result<Vec<ArtistRef>, ReadError> = nodeset
|
|
.iter()
|
|
.map(|node| {
|
|
XPathNodeReader::new(node, &context).and_then(|r| ArtistRef::from_xml(&r))
|
|
})
|
|
.collect();
|
|
res?
|
|
}
|
|
_ => Vec::new(),
|
|
},
|
|
})
|
|
}
|
|
|
|
fn issue1460() {
|
|
let _ = match foo {
|
|
REORDER_BUFFER_CHANGE_INTERNAL_SPEC_INSERT => {
|
|
"internal_spec_insert_internal_spec_insert_internal_spec_insert"
|
|
}
|
|
_ => "reorder_something",
|
|
};
|
|
}
|
|
|
|
fn issue525() {
|
|
foobar(
|
|
f,
|
|
"{}",
|
|
match *self {
|
|
TaskState::Started => "started",
|
|
TaskState::Success => "success",
|
|
TaskState::Failed => "failed",
|
|
},
|
|
);
|
|
}
|
|
|
|
// #1838, #1839
|
|
fn match_with_near_max_width() {
|
|
let (this_line_uses_99_characters_and_is_formatted_properly, x012345) = match some_expression {
|
|
_ => unimplemented!(),
|
|
};
|
|
|
|
let (should_be_formatted_like_the_line_above_using_100_characters, x0) = match some_expression {
|
|
_ => unimplemented!(),
|
|
};
|
|
|
|
let (should_put_the_brace_on_the_next_line_using_101_characters, x0000) = match some_expression
|
|
{
|
|
_ => unimplemented!(),
|
|
};
|
|
match m {
|
|
Variant::Tag
|
|
| Variant::Tag2
|
|
| Variant::Tag3
|
|
| Variant::Tag4
|
|
| Variant::Tag5
|
|
| Variant::Tag6 => {}
|
|
}
|
|
}
|
|
|
|
fn match_with_trailing_spaces() {
|
|
match x {
|
|
#![allow(simple_match)]
|
|
Some(..) => 0,
|
|
None => 1,
|
|
}
|
|
}
|
|
|
|
fn issue_2099() {
|
|
let a = match x {};
|
|
let b = match x {};
|
|
|
|
match x {}
|
|
}
|
|
|
|
// #2021
|
|
impl<'tcx> Const<'tcx> {
|
|
pub fn from_constval<'a>() -> Const<'tcx> {
|
|
let val = match *cv {
|
|
ConstVal::Variant(_) | ConstVal::Aggregate(..) | ConstVal::Unevaluated(..) => bug!(
|
|
"MIR must not use `{:?}` (aggregates are expanded to MIR rvalues)",
|
|
cv
|
|
),
|
|
};
|
|
}
|
|
}
|
|
|
|
// #2151
|
|
fn issue_2151() {
|
|
match either {
|
|
x => {}
|
|
y => (),
|
|
}
|
|
}
|
|
|
|
// #2152
|
|
fn issue_2152() {
|
|
match m {
|
|
"aaaaaaaaaaaaa" | "bbbbbbbbbbbbb" | "cccccccccccccccccccccccccccccccccccccccccccc"
|
|
if true => {}
|
|
"bind" | "writev" | "readv" | "sendmsg" | "recvmsg" if android && (aarch64 || x86_64) => {
|
|
true
|
|
}
|
|
}
|
|
}
|
|
|
|
// #2376
|
|
// Preserve block around expressions with condition.
|
|
fn issue_2376() {
|
|
let mut x = None;
|
|
match x {
|
|
Some(0) => {
|
|
for i in 1..11 {
|
|
x = Some(i);
|
|
}
|
|
}
|
|
Some(ref mut y) => {
|
|
while *y < 10 {
|
|
*y += 1;
|
|
}
|
|
}
|
|
None => {
|
|
while let None = x {
|
|
x = Some(10);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// #2621
|
|
// Strip leading `|` in match arm patterns
|
|
fn issue_2621() {
|
|
let x = Foo::A;
|
|
match x {
|
|
Foo::A => println!("No vert single condition"),
|
|
Foo::B | Foo::C => println!("Center vert two conditions"),
|
|
Foo::D => println!("Preceding vert single condition"),
|
|
Foo::E | Foo::F => println!("Preceding vert over two lines"),
|
|
Foo::G | Foo::H => println!("Trailing vert over two lines"),
|
|
// Comment on its own line
|
|
Foo::I => println!("With comment"), // Comment after line
|
|
}
|
|
}
|
|
|
|
fn issue_2377() {
|
|
match tok {
|
|
Tok::Not
|
|
| Tok::BNot
|
|
| Tok::Plus
|
|
| Tok::Minus
|
|
| Tok::PlusPlus
|
|
| Tok::MinusMinus
|
|
| Tok::Void
|
|
| Tok::Delete
|
|
if prec <= 16 =>
|
|
{
|
|
// code here...
|
|
}
|
|
Tok::TypeOf if prec <= 16 => {}
|
|
}
|
|
}
|
|
|
|
// #3040
|
|
fn issue_3040() {
|
|
{
|
|
match foo {
|
|
DevtoolScriptControlMsg::WantsLiveNotifications(id, to_send) => {
|
|
match documents.find_window(id) {
|
|
Some(window) => {
|
|
devtools::handle_wants_live_notifications(window.upcast(), to_send)
|
|
}
|
|
None => return warn!("Message sent to closed pipeline {}.", id),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// #3030
|
|
fn issue_3030() {
|
|
match input.trim().parse::<f64>() {
|
|
Ok(val)
|
|
if !(
|
|
// A valid number is the same as what rust considers to be valid,
|
|
// except for +1., NaN, and Infinity.
|
|
val.is_infinite() || val.is_nan() || input.ends_with(".") || input.starts_with("+")
|
|
) => {}
|
|
}
|
|
}
|
|
|
|
fn issue_3005() {
|
|
match *token {
|
|
Token::Dimension {
|
|
value, ref unit, ..
|
|
} if num_context.is_ok(context.parsing_mode, value) => {
|
|
return NoCalcLength::parse_dimension(context, value, unit)
|
|
.map(LengthOrPercentage::Length)
|
|
.map_err(|()| location.new_unexpected_token_error(token.clone()))
|
|
}
|
|
}
|
|
}
|