f1d29ff580
Test that the opening brace of trait with long name or bounds with multiple lines will be put on the next line.
232 lines
3.1 KiB
Rust
232 lines
3.1 KiB
Rust
// rustfmt-normalize_comments: true
|
|
impl Foo for Bar {
|
|
fn foo() {
|
|
"hi"
|
|
}
|
|
}
|
|
|
|
pub impl Foo for Bar {
|
|
// Associated Constants
|
|
const Baz: i32 = 16;
|
|
// Associated Types
|
|
type FooBar = usize;
|
|
// Comment 1
|
|
fn foo() {
|
|
"hi"
|
|
}
|
|
// Comment 2
|
|
fn foo() {
|
|
"hi"
|
|
}
|
|
// Comment 3
|
|
}
|
|
|
|
pub unsafe impl<'a, 'b, X, Y: Foo<Bar>> !Foo<'a, X> for Bar<'b, Y>
|
|
where
|
|
X: Foo<'a, Z>,
|
|
{
|
|
fn foo() {
|
|
"hi"
|
|
}
|
|
}
|
|
|
|
impl<'a, 'b, X, Y: Foo<Bar>> Foo<'a, X> for Bar<'b, Y>
|
|
where
|
|
X: Fooooooooooooooooooooooooooooo<'a, Z>,
|
|
{
|
|
fn foo() {
|
|
"hi"
|
|
}
|
|
}
|
|
|
|
impl<'a, 'b, X, Y: Foo<Bar>> Foo<'a, X> for Bar<'b, Y>
|
|
where
|
|
X: Foooooooooooooooooooooooooooo<'a, Z>,
|
|
{
|
|
fn foo() {
|
|
"hi"
|
|
}
|
|
}
|
|
|
|
impl<T> Foo for Bar<T>
|
|
where
|
|
T: Baz,
|
|
{
|
|
}
|
|
|
|
impl<T> Foo for Bar<T>
|
|
where
|
|
T: Baz,
|
|
{
|
|
// Comment
|
|
}
|
|
|
|
impl Foo {
|
|
fn foo() {}
|
|
}
|
|
|
|
impl Boo {
|
|
// BOO
|
|
fn boo() {}
|
|
// FOO
|
|
}
|
|
|
|
mod a {
|
|
impl Foo {
|
|
// Hello!
|
|
fn foo() {}
|
|
}
|
|
}
|
|
|
|
mod b {
|
|
mod a {
|
|
impl Foo {
|
|
fn foo() {}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Foo {
|
|
add_fun!();
|
|
}
|
|
|
|
impl Blah {
|
|
fn boop() {}
|
|
add_fun!();
|
|
}
|
|
|
|
impl X {
|
|
fn do_parse(mut self: X) {}
|
|
}
|
|
|
|
impl Y5000 {
|
|
fn bar(self: X<'a, 'b>, y: Y) {}
|
|
|
|
fn bad(&self, (x, y): CoorT) {}
|
|
|
|
fn turbo_bad(self: X<'a, 'b>, (x, y): CoorT) {}
|
|
}
|
|
|
|
pub impl<T> Foo for Bar<T>
|
|
where
|
|
T: Foo,
|
|
{
|
|
fn foo() {
|
|
"hi"
|
|
}
|
|
}
|
|
|
|
pub impl<T, Z> Foo for Bar<T, Z>
|
|
where
|
|
T: Foo,
|
|
Z: Baz,
|
|
{
|
|
}
|
|
|
|
mod m {
|
|
impl<T> PartialEq for S<T>
|
|
where
|
|
T: PartialEq,
|
|
{
|
|
fn eq(&self, other: &Self) {
|
|
true
|
|
}
|
|
}
|
|
|
|
impl<T> PartialEq for S<T>
|
|
where
|
|
T: PartialEq,
|
|
{
|
|
}
|
|
}
|
|
|
|
impl<BorrowType, K, V, NodeType, HandleType>
|
|
Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType>
|
|
{
|
|
}
|
|
|
|
impl<BorrowType, K, V, NodeType, HandleType> PartialEq
|
|
for Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType>
|
|
{
|
|
}
|
|
|
|
mod x {
|
|
impl<A, B, C, D> Foo
|
|
where
|
|
A: 'static,
|
|
B: 'static,
|
|
C: 'static,
|
|
D: 'static,
|
|
{
|
|
}
|
|
}
|
|
|
|
impl<ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNodeFoo>
|
|
Issue1249<ConcreteThreadSafeLayoutNode>
|
|
{
|
|
// Creates a new flow constructor.
|
|
fn foo() {}
|
|
}
|
|
|
|
// #1600
|
|
impl<#[may_dangle] K, #[may_dangle] V> Drop for RawTable<K, V> {
|
|
fn drop() {}
|
|
}
|
|
|
|
// #1168
|
|
pub trait Number
|
|
: Copy
|
|
+ Eq
|
|
+ Not<Output = Self>
|
|
+ Shl<u8, Output = Self>
|
|
+ Shr<u8, Output = Self>
|
|
+ BitAnd<Self, Output = Self>
|
|
+ BitOr<Self, Output = Self>
|
|
+ BitAndAssign
|
|
+ BitOrAssign
|
|
{
|
|
// test
|
|
fn zero() -> Self;
|
|
}
|
|
|
|
// #1642
|
|
pub trait SomeTrait
|
|
: Clone
|
|
+ Eq
|
|
+ PartialEq
|
|
+ Ord
|
|
+ PartialOrd
|
|
+ Default
|
|
+ Hash
|
|
+ Debug
|
|
+ Display
|
|
+ Write
|
|
+ Read
|
|
+ FromStr
|
|
{
|
|
// comment
|
|
}
|
|
|
|
// #1995
|
|
impl Foo {
|
|
fn f(
|
|
S {
|
|
aaaaaaaaaa: aaaaaaaaaa,
|
|
bbbbbbbbbb: bbbbbbbbbb,
|
|
cccccccccc: cccccccccc,
|
|
}: S,
|
|
) -> u32 {
|
|
1
|
|
}
|
|
}
|
|
|
|
// #2491
|
|
impl<'a, 'b, 'c> SomeThing<Something>
|
|
for (
|
|
&'a mut SomethingLong,
|
|
&'b mut SomethingLong,
|
|
&'c mut SomethingLong,
|
|
)
|
|
{
|
|
fn foo() {}
|
|
}
|