bon 3.9.1

Next-gen compile-time-checked builder generator, named function's arguments, and more!
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

// Members marked with `#[builder(start_fn)]` should be available as a private fields in the builder.
mod native_start_fn_fields {
    use crate::prelude::*;

    #[test]
    fn test_struct() {
        #[derive(Builder)]
        struct Sut {
            #[builder(start_fn)]
            #[allow(dead_code)]
            x1: u32,

            #[builder(start_fn)]
            #[allow(dead_code)]
            x2: bool,
        }

        let builder = Sut::builder(1, true);
        let x1: &u32 = &builder.x1;
        let x2: &bool = &builder.x2;

        assert_eq!(*x1, 1);
        assert!(*x2);
    }

    #[test]
    fn test_function() {
        #[builder]
        fn sut(#[builder(start_fn)] x1: u32, #[builder(start_fn)] x2: bool) {
            let _ = x1;
            let _ = x2;
        }

        let builder = sut(1, true);
        let x1: &u32 = &builder.x1;
        let x2: &bool = &builder.x2;

        assert_eq!(*x1, 1);
        assert!(*x2);
    }

    #[test]
    fn test_method() {
        struct Sut;

        #[bon]
        impl Sut {
            #[builder]
            fn method(#[builder(start_fn)] x1: u32, #[builder(start_fn)] x2: bool) {
                let _ = x1;
                let _ = x2;
            }
        }

        let builder = Sut::method(1, true);
        let x1: &u32 = &builder.x1;
        let x2: &bool = &builder.x2;

        assert_eq!(*x1, 1);
        assert!(*x2);
    }
}

mod native_receiver_field {
    use crate::prelude::*;

    // The `self_receiver` field in the builder should be available as a private field in the builder.
    #[test]
    fn native_receiver_field_smoke() {
        struct Sut {
            x1: u32,
        }

        #[bon]
        impl Sut {
            #[builder]
            fn method(self) {
                let _ = self;
            }

            #[builder]
            fn method_ref(&self) {
                let _ = self;
            }

            #[builder]
            fn method_mut(&mut self) {
                self.x1 += 1;
                let _ = self;
            }
        }

        {
            let builder = Sut { x1: 99 }.method();
            let receiver: Sut = builder.self_receiver;

            assert_eq!(receiver.x1, 99);
        }

        {
            let builder = Sut { x1: 99 }.method_ref();
            let receiver: &Sut = builder.self_receiver;

            assert_eq!(receiver.x1, 99);
        }

        {
            let mut sut = Sut { x1: 99 };
            let builder = sut.method_mut();
            let receiver: &mut Sut = builder.self_receiver;

            assert_eq!(receiver.x1, 99);
        }
    }

    #[test]
    fn name_conflict_resolution_for_receiver_field() {
        struct Sut {
            x1: u32,
        }

        #[bon]
        impl Sut {
            #[builder]
            fn method(
                &self,
                #[builder(start_fn)] self_receiver: u32,
                #[builder(start_fn)] self_receiver_: bool,
            ) {
                let _ = self_receiver;
                let _ = self_receiver_;
                let _ = self;
            }
        }

        let builder = Sut { x1: 99 }.method(2, true);
        let self_receiver: &u32 = &builder.self_receiver;
        let self_receiver_: &bool = &builder.self_receiver_;
        let self_receiver__: &Sut = builder.self_receiver__;

        assert_eq!(*self_receiver, 2);
        assert!(*self_receiver_);
        assert_eq!(self_receiver__.x1, 99);
    }
}