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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

//! Parse Rust source files for #\[swift_bridge::bridge\] modules and then generate the
//! corresponding C header files and Swift files.

#![deny(missing_docs)]

mod package;
use crate::generate_core::write_core_swift_and_c;
pub use package::*;
use std::path::Path;
use swift_bridge_ir::{CodegenConfig, SwiftBridgeModule};
use syn::__private::ToTokens;
use syn::{File, Item};

mod generate_core;

/// Parse rust sources files for `#\[swift_bridge::bridge\]` headers and generate the corresponding
/// Swift files.
pub fn parse_bridges(
    rust_source_files: impl IntoIterator<Item = impl AsRef<Path>>,
) -> GeneratedCode {
    let mut generated_code = GeneratedCode::new();

    for rust_file in rust_source_files.into_iter() {
        let rust_file: &Path = rust_file.as_ref();

        let file = std::fs::read_to_string(rust_file).unwrap();
        let gen = match parse_file_contents(&file) {
            Ok(generated) => generated,
            Err(e) => {
                // TODO: Return an error...
                panic!(
                    r#"
Error while parsing {:?}
{}
"#,
                    rust_file, e
                )
            }
        };

        generated_code.generated.push(gen);
    }

    generated_code
}

/// Generated Swift files and C headers.
pub struct GeneratedCode {
    generated: Vec<GeneratedFromSwiftBridgeModule>,
}

impl GeneratedCode {
    fn new() -> Self {
        GeneratedCode { generated: vec![] }
    }
}

impl GeneratedCode {
    /// Write all of the generated Swift to a single Swift file and all of the generated C headers
    /// to a single header file.
    pub fn write_all_concatenated(&self, swift_bridge_out_dir: impl AsRef<Path>, crate_name: &str) {
        let swift_bridge_out_dir = swift_bridge_out_dir.as_ref();

        let mut concatenated_swift = "".to_string();
        let mut concatenated_c = "".to_string();

        for gen in &self.generated {
            concatenated_swift += &gen.swift;
            concatenated_c += &gen.c_header;
        }

        let out = swift_bridge_out_dir.join(&crate_name);
        match std::fs::create_dir_all(&out) {
            Ok(_) => {}
            Err(_) => {}
        };

        std::fs::write(out.join(format!("{}.h", crate_name)), concatenated_c).unwrap();
        std::fs::write(
            out.join(format!("{}.swift", crate_name)),
            concatenated_swift,
        )
        .unwrap();

        write_core_swift_and_c(swift_bridge_out_dir.as_ref());
    }

    /// Concatenate all of the generated Swift code into one file.
    pub fn concat_swift(&self) -> String {
        let mut swift = "".to_string();

        for gen in &self.generated {
            swift += &gen.swift;
        }

        swift
    }

    /// Concatenate all of the generated C code into one file.
    pub fn concat_c(&self) -> String {
        let mut c_header = "".to_string();

        for gen in &self.generated {
            c_header += &gen.c_header;
        }

        c_header
    }
}

fn parse_file_contents(file: &str) -> syn::Result<GeneratedFromSwiftBridgeModule> {
    let file: File = syn::parse_str(file)?;

    let mut generated = GeneratedFromSwiftBridgeModule {
        c_header: "".to_string(),
        swift: "".to_string(),
    };

    for item in file.items {
        match item {
            Item::Mod(module) => {
                // TODO: Move this check into the `impl Parse for SwiftBridgeModule`.. Modify our
                //  tests in swift-bridge-ir to annotate modules with `#[swift_bridge::bridge]`
                if module.attrs.iter().any(|a| {
                    let attrib = a.path.to_token_stream().to_string();
                    attrib == "swift_bridge :: bridge" || attrib == "swift_bridge_macro :: bridge"
                }) {
                    let module: SwiftBridgeModule = syn::parse2(module.to_token_stream())?;

                    let config = CodegenConfig {
                        crate_feature_lookup: Box::new(|feature_name| {
                            let normalized_feature_name = feature_name.replace("-", "_");
                            let normalized_feature_name = normalized_feature_name.to_uppercase();

                            let env_var_name = format!("CARGO_FEATURE_{}", normalized_feature_name);
                            std::env::var(env_var_name).is_ok()
                        }),
                    };
                    let swift_and_c = module.generate_swift_code_and_c_header(config);

                    generated.c_header += &swift_and_c.c_header;
                    generated.c_header += "\n\n";

                    let swift = &swift_and_c.swift;
                    generated.swift += &swift;
                    generated.swift += "\n\n";
                }
            }
            _ => {}
        }
    }

    Ok(generated)
}

#[derive(Debug)]
struct GeneratedFromSwiftBridgeModule {
    c_header: String,
    swift: String,
}