zyn 0.5.4

A proc macro framework with templates, composable elements, and built-in diagnostics
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

use zyn::ext::ItemExt;
use zyn::syn;

#[test]
fn is_struct() {
    assert!(zyn::parse!("struct Foo;" => syn::Item).unwrap().is_struct());
    assert!(
        !zyn::parse!("enum Bar { A }" => syn::Item)
            .unwrap()
            .is_struct()
    );
}

#[test]
fn is_enum() {
    assert!(
        zyn::parse!("enum Foo { A, B }" => syn::Item)
            .unwrap()
            .is_enum()
    );
    assert!(!zyn::parse!("struct Bar;" => syn::Item).unwrap().is_enum());
}

#[test]
fn is_fn() {
    assert!(zyn::parse!("fn foo() {}" => syn::Item).unwrap().is_fn());
    assert!(!zyn::parse!("struct Bar;" => syn::Item).unwrap().is_fn());
}

#[test]
fn ident_returns_name() {
    let item: syn::Item = zyn::parse!("struct MyStruct;" => syn::Item).unwrap();
    assert_eq!(item.ident().unwrap().to_string(), "MyStruct");
}

#[test]
fn ident_for_fn() {
    let item: syn::Item = zyn::parse!("fn my_func() {}" => syn::Item).unwrap();
    assert_eq!(item.ident().unwrap().to_string(), "my_func");
}

#[test]
fn attrs_from_item() {
    let item: syn::Item = zyn::parse!("#[derive(Debug)] struct Foo;" => syn::Item).unwrap();
    assert_eq!(item.attrs().len(), 1);
}

#[test]
fn vis_from_pub_struct() {
    let item: syn::Item = zyn::parse!("pub struct Foo;" => syn::Item).unwrap();
    let vis = item.vis().unwrap();
    assert!(matches!(vis, syn::Visibility::Public(_)));
}

#[test]
fn as_struct_converts() {
    let item: syn::Item = zyn::parse!("struct Foo { x: i32 }" => syn::Item).unwrap();
    let s = item.as_struct();
    assert!(s.is_some());
    assert_eq!(s.unwrap().ident.to_string(), "Foo");
}

#[test]
fn as_enum_converts() {
    let item: syn::Item = zyn::parse!("enum Color { Red, Green }" => syn::Item).unwrap();
    let e = item.as_enum();
    assert!(e.is_some());
    assert_eq!(e.unwrap().variants.len(), 2);
}

#[test]
fn generics_from_generic_struct() {
    let item: syn::Item = zyn::parse!("struct Foo<T, U> { x: T, y: U }" => syn::Item).unwrap();
    let generics = item.generics().unwrap();
    assert_eq!(generics.params.len(), 2);
}