echoes 0.12.0

Find duplicated Rust doctests, functions and contexts
Documentation 
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

//! Macro argument provenance in closed item groups.

#[path = "support/failing.rs"]
mod failing;
#[path = "support/form.rs"]
mod form;
#[path = "support/separate.rs"]
mod separate;

use failing::failing;
use form::form;
use separate::separate;

fn folded(left: &str, right: &str) {
    assert_eq!(form(left), form(right), "{left}\n{right}");
    assert_ne!(failing(left), failing(right), "{left}\n{right}");
}

#[test]
fn item_macros_fold_implicit_capture_references() {
    folded(
        "const A: u32 = 1; const B: u32 = 2; fn f() { println!(\"{A}\"); } fn g() { println!(\"{B}\"); }",
        "const B: u32 = 2; const A: u32 = 1; fn g() { println!(\"{B}\"); } fn f() { println!(\"{A}\"); }",
    );
}

#[test]
fn item_macros_fold_positional_and_named_arguments() {
    folded(
        "const A: u32 = 1; const B: u32 = 2; fn f() { let c = 3; println!(\"{A} {} {B}\", c); }",
        "const B: u32 = 2; const A: u32 = 1; fn f() { let c = 3; println!(\"{A} {} {B}\", c); }",
    );
}

#[test]
fn item_macros_fold_width_and_precision_references() {
    folded(
        "const W: usize = 8; const P: usize = 2; const V: u32 = 1; fn f() { println!(\"{V: W$.P$}\"); }",
        "const Q: usize = 2; const X: usize = 8; const V: u32 = 1; fn f() { println!(\"{V: X$.Q$}\"); }",
    );
}

#[test]
fn item_macros_keep_different_width_origins_separate() {
    separate(
        "const W: usize = 8; const U: usize = 24; fn f() { let v = 1; println!(\"{v: W$}\"); }",
        "const W: usize = 8; const U: usize = 24; fn f() { let v = 1; println!(\"{v: U$}\"); }",
    );
}

#[test]
fn item_macros_fold_nested_format_references() {
    folded(
        "const A: u32 = 1; const B: u32 = 2; fn f() { println!(\"{A} {}\", format!(\"{B}\")); }",
        "const B: u32 = 2; const A: u32 = 1; fn f() { println!(\"{A} {}\", format!(\"{B}\")); }",
    );
}

#[test]
fn item_macros_rebind_generic_arguments() {
    assert_eq!(
        form(
            "fn one<T>() { let t = 1; let w = 4; println!(\"{t: w$} {}\", core::mem::size_of::<T>()); }"
        ),
        form(
            "fn two<U>() { let u = 1; let w = 4; println!(\"{u: w$} {}\", core::mem::size_of::<U>()); }"
        ),
    );
}

#[test]
fn item_macros_freeze_unparsable_argument_groups() {
    separate(
        "fn one() -> u32 { 1 } fn two() -> u32 { 2 } fn main() { println!(; 3); }",
        "fn two() -> u32 { 2 } fn one() -> u32 { 1 } fn main() { println!(; 3); }",
    );
}

#[test]
fn item_macros_fold_nested_format_capture_names() {
    folded(
        "const A: u32 = 1; const B: u32 = 2; fn f() { let p = 3; println!(\"{} {}\", format!(\"{A} {B}\"), p); }",
        "const D: u32 = 2; const C: u32 = 1; fn g() { let q = 3; println!(\"{} {}\", format!(\"{C} {D}\"), q); }",
    );
}

#[test]
fn item_macros_keep_nested_format_origins_separate() {
    separate(
        "const A: u32 = 1; const B: u32 = 2; fn f() { println!(\"{}\", format!(\"{A}\")); }",
        "const A: u32 = 1; const B: u32 = 2; fn g() { println!(\"{}\", format!(\"{B}\")); }",
    );
}

#[test]
fn item_macros_rebind_raw_generic_arguments() {
    assert_eq!(
        form(
            "struct S<T>(T); impl<r#type> S<r#type> { fn one() { println!(\"{}\", core::mem::size_of::<r#type>()); } } impl<U> S<U> { fn two() { println!(\"{}\", core::mem::size_of::<U>()); } }"
        ),
        form(
            "struct S<T>(T); impl<V> S<V> { fn one() { println!(\"{}\", core::mem::size_of::<V>()); } } impl<W> S<W> { fn two() { println!(\"{}\", core::mem::size_of::<W>()); } }"
        ),
    );
}

#[test]
fn nested_unknown_macros_keep_ancestor_item_groups_atomic() {
    separate(
        "fn one() -> u32 { 1 } fn two() -> u32 { 2 } fn main() { println!(\"{:?}\", observer::order!((one(), two()))); }",
        "fn two() -> u32 { 2 } fn one() -> u32 { 1 } fn main() { println!(\"{:?}\", observer::order!((one(), two()))); }",
    );
}