sn_bindgen 0.13.18

A library to automatically generate C, Java, and C# files from Rust source files.
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

use crate::common::{Lang, Outputs};
use crate::{parse, Error};
use colored::*;
use std::collections::HashMap;
use std::fmt::Write;
use unwrap::unwrap;

macro_rules! compile {
    ($lang:expr, $rust:tt) => {
        unwrap!(try_compile!($lang, $rust))
    };
}

macro_rules! try_compile {
    ($lang:expr, $rust:tt) => {{
        let rust_src = stringify!($rust);
        let rust_src = rust_src[1..rust_src.len() - 1].to_string();
        use crate::test_utils;
        test_utils::try_compile($lang, rust_src)
    }};
}

// This is like `assert_eq`, but produces more readable output for multiline
// strings.
macro_rules! assert_multiline_eq {
    ($left:expr, $right:expr) => {{
        use crate::test_utils::format_diff;
        use colored::*;

        let left = $left;
        let right = $right;

        if left != right {
            panic!(
                "assertion failed: `({} == {})`\n```\n{}```\n",
                "left".red(),
                "right".green(),
                format_diff(&left, &right)
            );
        }
    }};
}

/// Convert source string into an AST type
pub fn ty(source: &str) -> syn::Type {
    let item: Result<syn::Type, _> = syn::parse_str(source);
    unwrap!(item)
}

pub fn try_compile(
    mut lang: impl Lang,
    rust_src: String,
) -> Result<HashMap<String, String>, Vec<Error>> {
    let ast: syn::File = unwrap!(syn::parse_str(&rust_src));
    let mut outputs = Outputs::default();
    parse::parse_file(&mut lang, &ast, &[Default::default()], &mut outputs)?;
    lang.finalise_output(&mut outputs)?;

    Ok(outputs)
}

pub fn format_diff(left: &str, right: &str) -> String {
    let mut output = String::new();

    for res in diff::lines(left, right) {
        match res {
            diff::Result::Left(line) => unwrap!(writeln!(output, "{}{}", "-".red(), line.red())),
            diff::Result::Right(line) => {
                unwrap!(writeln!(output, "{}{}", "+".green(), line.green()))
            }
            diff::Result::Both(line, _) => unwrap!(writeln!(output, " {}", line.white())),
        };
    }

    output
}

pub fn fetch<'a>(outputs: &'a HashMap<String, String>, name: &str) -> &'a str {
    outputs.get(name).map(String::as_str).unwrap_or("")
}