cxx_gen/syntax/
impls.rs

1use crate::syntax::{
2    Array, ExternFn, Include, Lifetimes, Ptr, Receiver, Ref, Signature, SliceRef, Ty1, Type, Var,
3};
4use std::hash::{Hash, Hasher};
5use std::mem;
6use std::ops::{Deref, DerefMut};
7
8impl PartialEq for Include {
9    fn eq(&self, other: &Self) -> bool {
10        let Include {
11            cfg: _,
12            path,
13            kind,
14            begin_span: _,
15            end_span: _,
16        } = self;
17        let Include {
18            cfg: _,
19            path: path2,
20            kind: kind2,
21            begin_span: _,
22            end_span: _,
23        } = other;
24        path == path2 && kind == kind2
25    }
26}
27
28impl Deref for ExternFn {
29    type Target = Signature;
30
31    fn deref(&self) -> &Self::Target {
32        &self.sig
33    }
34}
35
36impl DerefMut for ExternFn {
37    fn deref_mut(&mut self) -> &mut Self::Target {
38        &mut self.sig
39    }
40}
41
42impl Hash for Type {
43    fn hash<H: Hasher>(&self, state: &mut H) {
44        mem::discriminant(self).hash(state);
45        match self {
46            Type::Ident(t) => t.hash(state),
47            Type::RustBox(t) => t.hash(state),
48            Type::UniquePtr(t) => t.hash(state),
49            Type::SharedPtr(t) => t.hash(state),
50            Type::WeakPtr(t) => t.hash(state),
51            Type::Ref(t) => t.hash(state),
52            Type::Ptr(t) => t.hash(state),
53            Type::Str(t) => t.hash(state),
54            Type::RustVec(t) => t.hash(state),
55            Type::CxxVector(t) => t.hash(state),
56            Type::Fn(t) => t.hash(state),
57            Type::SliceRef(t) => t.hash(state),
58            Type::Array(t) => t.hash(state),
59            Type::Void(_) => {}
60        }
61    }
62}
63
64impl Eq for Type {}
65
66impl PartialEq for Type {
67    fn eq(&self, other: &Self) -> bool {
68        match (self, other) {
69            (Type::Ident(lhs), Type::Ident(rhs)) => lhs == rhs,
70            (Type::RustBox(lhs), Type::RustBox(rhs)) => lhs == rhs,
71            (Type::UniquePtr(lhs), Type::UniquePtr(rhs)) => lhs == rhs,
72            (Type::SharedPtr(lhs), Type::SharedPtr(rhs)) => lhs == rhs,
73            (Type::WeakPtr(lhs), Type::WeakPtr(rhs)) => lhs == rhs,
74            (Type::Ref(lhs), Type::Ref(rhs)) => lhs == rhs,
75            (Type::Str(lhs), Type::Str(rhs)) => lhs == rhs,
76            (Type::RustVec(lhs), Type::RustVec(rhs)) => lhs == rhs,
77            (Type::CxxVector(lhs), Type::CxxVector(rhs)) => lhs == rhs,
78            (Type::Fn(lhs), Type::Fn(rhs)) => lhs == rhs,
79            (Type::SliceRef(lhs), Type::SliceRef(rhs)) => lhs == rhs,
80            (Type::Void(_), Type::Void(_)) => true,
81            (_, _) => false,
82        }
83    }
84}
85
86impl Eq for Lifetimes {}
87
88impl PartialEq for Lifetimes {
89    fn eq(&self, other: &Self) -> bool {
90        let Lifetimes {
91            lt_token: _,
92            lifetimes,
93            gt_token: _,
94        } = self;
95        let Lifetimes {
96            lt_token: _,
97            lifetimes: lifetimes2,
98            gt_token: _,
99        } = other;
100        lifetimes.iter().eq(lifetimes2)
101    }
102}
103
104impl Hash for Lifetimes {
105    fn hash<H: Hasher>(&self, state: &mut H) {
106        let Lifetimes {
107            lt_token: _,
108            lifetimes,
109            gt_token: _,
110        } = self;
111        lifetimes.len().hash(state);
112        for lifetime in lifetimes {
113            lifetime.hash(state);
114        }
115    }
116}
117
118impl Eq for Ty1 {}
119
120impl PartialEq for Ty1 {
121    fn eq(&self, other: &Self) -> bool {
122        let Ty1 {
123            name,
124            langle: _,
125            inner,
126            rangle: _,
127        } = self;
128        let Ty1 {
129            name: name2,
130            langle: _,
131            inner: inner2,
132            rangle: _,
133        } = other;
134        name == name2 && inner == inner2
135    }
136}
137
138impl Hash for Ty1 {
139    fn hash<H: Hasher>(&self, state: &mut H) {
140        let Ty1 {
141            name,
142            langle: _,
143            inner,
144            rangle: _,
145        } = self;
146        name.hash(state);
147        inner.hash(state);
148    }
149}
150
151impl Eq for Ref {}
152
153impl PartialEq for Ref {
154    fn eq(&self, other: &Self) -> bool {
155        let Ref {
156            pinned,
157            ampersand: _,
158            lifetime,
159            mutable,
160            inner,
161            pin_tokens: _,
162            mutability: _,
163        } = self;
164        let Ref {
165            pinned: pinned2,
166            ampersand: _,
167            lifetime: lifetime2,
168            mutable: mutable2,
169            inner: inner2,
170            pin_tokens: _,
171            mutability: _,
172        } = other;
173        pinned == pinned2 && lifetime == lifetime2 && mutable == mutable2 && inner == inner2
174    }
175}
176
177impl Hash for Ref {
178    fn hash<H: Hasher>(&self, state: &mut H) {
179        let Ref {
180            pinned,
181            ampersand: _,
182            lifetime,
183            mutable,
184            inner,
185            pin_tokens: _,
186            mutability: _,
187        } = self;
188        pinned.hash(state);
189        lifetime.hash(state);
190        mutable.hash(state);
191        inner.hash(state);
192    }
193}
194
195impl Eq for Ptr {}
196
197impl PartialEq for Ptr {
198    fn eq(&self, other: &Ptr) -> bool {
199        let Ptr {
200            star: _,
201            mutable,
202            inner,
203            mutability: _,
204            constness: _,
205        } = self;
206        let Ptr {
207            star: _,
208            mutable: mutable2,
209            inner: inner2,
210            mutability: _,
211            constness: _,
212        } = other;
213        mutable == mutable2 && inner == inner2
214    }
215}
216
217impl Hash for Ptr {
218    fn hash<H: Hasher>(&self, state: &mut H) {
219        let Ptr {
220            star: _,
221            mutable,
222            inner,
223            mutability: _,
224            constness: _,
225        } = self;
226        mutable.hash(state);
227        inner.hash(state);
228    }
229}
230
231impl Eq for SliceRef {}
232
233impl PartialEq for SliceRef {
234    fn eq(&self, other: &Self) -> bool {
235        let SliceRef {
236            ampersand: _,
237            lifetime,
238            mutable,
239            bracket: _,
240            inner,
241            mutability: _,
242        } = self;
243        let SliceRef {
244            ampersand: _,
245            lifetime: lifetime2,
246            mutable: mutable2,
247            bracket: _,
248            inner: inner2,
249            mutability: _,
250        } = other;
251        lifetime == lifetime2 && mutable == mutable2 && inner == inner2
252    }
253}
254
255impl Hash for SliceRef {
256    fn hash<H: Hasher>(&self, state: &mut H) {
257        let SliceRef {
258            ampersand: _,
259            lifetime,
260            mutable,
261            bracket: _,
262            inner,
263            mutability: _,
264        } = self;
265        lifetime.hash(state);
266        mutable.hash(state);
267        inner.hash(state);
268    }
269}
270
271impl Eq for Array {}
272
273impl PartialEq for Array {
274    fn eq(&self, other: &Self) -> bool {
275        let Array {
276            bracket: _,
277            inner,
278            semi_token: _,
279            len,
280            len_token: _,
281        } = self;
282        let Array {
283            bracket: _,
284            inner: inner2,
285            semi_token: _,
286            len: len2,
287            len_token: _,
288        } = other;
289        inner == inner2 && len == len2
290    }
291}
292
293impl Hash for Array {
294    fn hash<H: Hasher>(&self, state: &mut H) {
295        let Array {
296            bracket: _,
297            inner,
298            semi_token: _,
299            len,
300            len_token: _,
301        } = self;
302        inner.hash(state);
303        len.hash(state);
304    }
305}
306
307impl Eq for Signature {}
308
309impl PartialEq for Signature {
310    fn eq(&self, other: &Self) -> bool {
311        let Signature {
312            asyncness,
313            unsafety,
314            fn_token: _,
315            generics: _,
316            receiver,
317            args,
318            ret,
319            throws,
320            paren_token: _,
321            throws_tokens: _,
322        } = self;
323        let Signature {
324            asyncness: asyncness2,
325            unsafety: unsafety2,
326            fn_token: _,
327            generics: _,
328            receiver: receiver2,
329            args: args2,
330            ret: ret2,
331            throws: throws2,
332            paren_token: _,
333            throws_tokens: _,
334        } = other;
335        asyncness.is_some() == asyncness2.is_some()
336            && unsafety.is_some() == unsafety2.is_some()
337            && receiver == receiver2
338            && ret == ret2
339            && throws == throws2
340            && args.len() == args2.len()
341            && args.iter().zip(args2).all(|(arg, arg2)| {
342                let Var {
343                    cfg: _,
344                    doc: _,
345                    attrs: _,
346                    visibility: _,
347                    name: _,
348                    colon_token: _,
349                    ty,
350                } = arg;
351                let Var {
352                    cfg: _,
353                    doc: _,
354                    attrs: _,
355                    visibility: _,
356                    name: _,
357                    colon_token: _,
358                    ty: ty2,
359                } = arg2;
360                ty == ty2
361            })
362    }
363}
364
365impl Hash for Signature {
366    fn hash<H: Hasher>(&self, state: &mut H) {
367        let Signature {
368            asyncness,
369            unsafety,
370            fn_token: _,
371            generics: _,
372            receiver,
373            args,
374            ret,
375            throws,
376            paren_token: _,
377            throws_tokens: _,
378        } = self;
379        asyncness.is_some().hash(state);
380        unsafety.is_some().hash(state);
381        receiver.hash(state);
382        for arg in args {
383            let Var {
384                cfg: _,
385                doc: _,
386                attrs: _,
387                visibility: _,
388                name: _,
389                colon_token: _,
390                ty,
391            } = arg;
392            ty.hash(state);
393        }
394        ret.hash(state);
395        throws.hash(state);
396    }
397}
398
399impl Eq for Receiver {}
400
401impl PartialEq for Receiver {
402    fn eq(&self, other: &Self) -> bool {
403        let Receiver {
404            pinned,
405            ampersand: _,
406            lifetime,
407            mutable,
408            var: _,
409            colon_token: _,
410            ty,
411            shorthand: _,
412            pin_tokens: _,
413            mutability: _,
414        } = self;
415        let Receiver {
416            pinned: pinned2,
417            ampersand: _,
418            lifetime: lifetime2,
419            mutable: mutable2,
420            var: _,
421            colon_token: _,
422            ty: ty2,
423            shorthand: _,
424            pin_tokens: _,
425            mutability: _,
426        } = other;
427        pinned == pinned2 && lifetime == lifetime2 && mutable == mutable2 && ty == ty2
428    }
429}
430
431impl Hash for Receiver {
432    fn hash<H: Hasher>(&self, state: &mut H) {
433        let Receiver {
434            pinned,
435            ampersand: _,
436            lifetime,
437            mutable,
438            var: _,
439            colon_token: _,
440            ty,
441            shorthand: _,
442            pin_tokens: _,
443            mutability: _,
444        } = self;
445        pinned.hash(state);
446        lifetime.hash(state);
447        mutable.hash(state);
448        ty.hash(state);
449    }
450}
cxx_gen/syntax/impls.rs

cxx_gen/syntax/
impls.rs
