trans.rs

use quote::{Ident, Tokens};
use syn::{Lit, StrStyle};

use analyze::{Ownership, Ownerships};
use check::App;

fn krate() -> Ident {
    Ident::from("rtfm")
}

pub fn app(app: &App, ownerships: &Ownerships) -> Tokens {
    let mut root = vec![];
    let mut main = vec![];

    ::trans::check(app, &mut main);
    ::trans::init(app, &mut main, &mut root);
    ::trans::idle(app, ownerships, &mut main, &mut root);
    ::trans::resources(app, ownerships, &mut root);
    ::trans::tasks(app, ownerships, &mut root);

    root.push(quote! {
        #[allow(unsafe_code)]
        fn main() {
            #(#main)*
        }
    });

    quote!(#(#root)*)
}

// Checks that the resource types are valid
// Sadly we can't do this test at expansion time. Instead we'll generate some
// code that won't compile if the types don't meet the requirements
fn check(app: &App, main: &mut Vec<Tokens>) {
    if !app.resources.is_empty() {
        main.push(quote! {
            fn is_send<T>() where T: Send {}
        });
    }

    for resource in app.resources.values() {
        let ty = &resource.ty;

        main.push(quote! {
            is_send::<#ty>();
        });
    }
}

fn idle(
    app: &App,
    ownerships: &Ownerships,
    main: &mut Vec<Tokens>,
    root: &mut Vec<Tokens>,
) {
    let krate = krate();

    let mut mod_items = vec![];
    let mut tys = vec![];
    let mut exprs = vec![];

    if !app.idle.resources.is_empty() {
        tys.push(quote!(&mut #krate::Threshold));
        exprs.push(quote!(unsafe { &mut #krate::Threshold::new(0) }));
    }

    if !app.idle.resources.is_empty() {
        let device = &app.device;

        let mut needs_reexport = false;