1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
// 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() {}
}
|
