chloro-core 0.7.5

Core functionality for chloro - a minimal Rust code formatter
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
114

use super::*;
use insta::assert_snapshot;

#[test]
fn preserve_inner_attribute_allow() {
    let input = "#![allow(non_camel_case_types)]\n";
    let output = format_source(input);
    assert_snapshot!(output, @"#![allow(non_camel_case_types)]
");
}

#[test]
fn preserve_inner_attribute_feature() {
    let input = "#![feature(test)]\n";
    let output = format_source(input);
    assert_snapshot!(output, @"#![feature(test)]
");
}

#[test]
fn preserve_outer_attribute_derive() {
    let input = "#[derive(Debug, Clone)]\nstruct Foo;\n";
    let output = format_source(input);
    assert_snapshot!(output, @r"
    #[derive(Debug, Clone)]
    struct Foo;
    ");
}

#[test]
fn preserve_nested_attribute_content() {
    let input = r#"#[cfg(all(feature = "foo", target_os = "linux"))]
fn foo() {}
"#;
    let output = format_source(input);
    assert!(output.contains(r#"#[cfg(all(feature = "foo", target_os = "linux"))]"#));
}

#[test]
fn preserve_extern_block_with_function() {
    let input = r#"extern "C" { fn printf(format: *const i8, ...) -> i32; }"#;
    let output = format_source(input);
    assert_snapshot!(output, @r#"
    extern "C" {
        fn printf(format: *const i8, ...) -> i32;
    }
    "#);
}

#[test]
fn preserve_extern_block_multiline() {
    let input = r#"extern "C" {
    fn printf(format: *const i8, ...) -> i32;
    fn exit(code: i32) -> !;
}
"#;
    let output = format_source(input);
    assert_snapshot!(output, @r#"
    extern "C" {
        fn printf(format: *const i8, ...) -> i32;
        fn exit(code: i32) -> !;
    }
    "#);
}

#[test]
fn preserve_unsafe_extern_block() {
    let input = r#"unsafe extern "C" {}"#;
    let output = format_source(input);
    assert_snapshot!(output, @r#"unsafe extern "C" {}"#);
}

#[test]
fn preserve_extern_block_with_attributed_variadic() {
    let input = r#"extern "C" { fn printf(format: *const i8, #[attr] ...) -> i32; }"#;
    let output = format_source(input);
    assert_snapshot!(output, @r#"
    extern "C" {
        fn printf(format: *const i8, #[attr] ...) -> i32;
    }
    "#);
}

#[test]
fn preserve_inner_attribute_full_content() {
    let input = r#"#![allow(non_camel_case_types)]
#![allow(dead_code)]
#![allow(unreachable_code)]
#![recursion_limit = "128"]
"#;
    let output = format_source(input);
    assert_snapshot!(output, @r#"
    #![allow(non_camel_case_types)]
    #![allow(dead_code)]
    #![allow(unreachable_code)]
    #![recursion_limit = "128"]
    "#);
}

#[test]
fn preserve_multiple_inner_attributes_with_blank_line() {
    let input = r#"#![allow(non_camel_case_types)]
#![allow(dead_code)]

#![recursion_limit = "128"]
"#;
    let output = format_source(input);
    assert_snapshot!(output, @r#"
    #![allow(non_camel_case_types)]
    #![allow(dead_code)]

    #![recursion_limit = "128"]
    "#);
}