clang 2.1.0

A somewhat idiomatic Rust wrapper for libclang.
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

use clang::documentation::*;
use clang::*;

pub fn test(clang: &Clang) {
    let source = r#"
        int a();
        /// \brief This is a function.
        ///
        /// This function does stuff and then returns an \c int for reasons unknown.
        ///
        /// <br />
        /// <a href="http://example.com">More information.</a>
        ///
        /// \tparam T This template parameter doesn't actually do anything.
        /// \param [in] i This parameter alters the behavior of the function in some way.
        ///
        /// \verbatim *nullptr \endverbatim
        template <typename T>
        int b(int i) { return i; }
    "#;

    super::with_entity(&clang, source, |e| {
        let children = e.get_children();
        assert_eq!(children.len(), 2);

        assert!(children[0].get_parsed_comment().is_none());

        let comment = children[1].get_parsed_comment().unwrap();
        assert!(!comment.as_html().is_empty());
        assert!(!comment.as_xml().is_empty());

        let children = comment.get_children();
        assert_eq!(children.len(), 9);

        assert_eq!(
            children[0],
            CommentChild::Paragraph(vec![CommentChild::Text(" ".into()),])
        );
        assert_eq!(
            children[1],
            CommentChild::BlockCommand(BlockCommand {
                command: "brief".into(),
                arguments: vec![],
                children: vec![CommentChild::Text(" This is a function.".into()),]
            })
        );
        assert_eq!(
            children[2],
            CommentChild::Paragraph(vec![
                CommentChild::Text(" This function does stuff and then returns an ".into()),
                CommentChild::InlineCommand(InlineCommand {
                    command: "c".into(),
                    arguments: vec!["int".into()],
                    style: Some(InlineCommandStyle::Monospace),
                }),
                CommentChild::Text(" for reasons unknown.".into()),
            ])
        );
        assert_eq!(
            children[3],
            CommentChild::Paragraph(vec![
                CommentChild::Text(" ".into()),
                CommentChild::HtmlStartTag(HtmlStartTag {
                    name: "br".into(),
                    attributes: vec![],
                    closing: true
                }),
                CommentChild::Text(" ".into()),
                CommentChild::HtmlStartTag(HtmlStartTag {
                    name: "a".into(),
                    attributes: vec![("href".into(), "http://example.com".into())],
                    closing: false
                }),
                CommentChild::Text("More information.".into()),
                CommentChild::HtmlEndTag("a".into()),
            ])
        );
        assert_eq!(
            children[4],
            CommentChild::Paragraph(vec![CommentChild::Text(" ".into()),])
        );
        assert_eq!(
            children[5],
            CommentChild::TParamCommand(TParamCommand {
                position: Some((1, 0)),
                parameter: "T".into(),
                children: vec![
                    CommentChild::Text(
                        " This template parameter doesn't actually do anything.".into()
                    ),
                    CommentChild::Text(" ".into()),
                ]
            })
        );
        assert_eq!(
            children[6],
            CommentChild::ParamCommand(ParamCommand {
                index: Some(0),
                parameter: "i".into(),
                direction: Some(ParameterDirection::In),
                children: vec![CommentChild::Text(
                    " This parameter alters the behavior of the function in some way.".into()
                ),]
            })
        );
        assert_eq!(
            children[7],
            CommentChild::Paragraph(vec![CommentChild::Text(" ".into()),])
        );
        assert_eq!(
            children[8],
            CommentChild::VerbatimCommand(vec![" *nullptr ".into()])
        );
    });
}