Add codegen for new rust yunq parser.

yunq/rust/src/codegen.rs

@@ -1,53 +1,116 @@
-use crate::parser::{Decl, Field, Interface, Message};
-use genco::fmt;
-use genco::fmt::FmtWriter;
-use genco::prelude::quote_fn;
-use genco::prelude::quote_in;
-use genco::prelude::rust;
-use genco::prelude::FormatInto;
-use genco::prelude::Rust;
+use crate::parser::{Decl, Interface, Message, Method};
+use convert_case::{Case, Casing};
+use proc_macro2::Ident;
+use proc_macro2::Span;
+use proc_macro2::TokenStream;
+use quote::quote;
 
-pub fn generate_field_def<'a>(field: &'a Field) -> impl FormatInto<Rust> + 'a {
-    quote_fn!(
-        $(field.name.clone()): $(field.field_type.rust_type()),
-    )
+fn ident(s: &str) -> Ident {
+    Ident::new(s, Span::call_site())
 }
 
-pub fn generate_message_code<'a>(message: &'a Message) -> impl FormatInto<Rust> + 'a {
-    quote_fn!(
-    struct $(&message.name) {$['\r']
-    $(for field in &message.fields =>
-        $[' ']$(generate_field_def(field))$['\r']
-    )}$['\n']
-
-    impl $(&message.name) {$['\r']
-        jjj
-
-    }$['\n']
-    )
-}
-
-pub fn generate_code(ast: &Vec<Decl>) -> Result<String, std::fmt::Error> {
-    let mut tokens = rust::Tokens::new();
-
-    for decl in ast {
-        match decl {
-            Decl::Message(message) => quote_in!(tokens => $(generate_message_code(message))),
-            _ => {}
+fn generate_message(message: &Message) -> TokenStream {
+    let name = ident(&message.name);
+    let field_names = message.fields.iter().map(|f| ident(&f.name));
+    let field_types = message
+        .fields
+        .iter()
+        .map(|f| Ident::new(f.field_type.rust_type(), Span::call_site()));
+    quote! {
+        #[derive(YunqMessage)]
+        pub struct #name {
+            #(pub #field_names: #field_types),*
         }
+
     }
-
-    let mut w = FmtWriter::new(String::new());
-
-    let fmt = fmt::Config::from_lang::<Rust>()
-        .with_indentation(fmt::Indentation::Space(4))
-        .with_newline("\n");
-
-    let config = rust::Config::default()
-        // Prettier imports and use.
-        .with_default_import(rust::ImportMode::Qualified);
-
-    tokens.format_file(&mut w.as_formatter(&fmt), &config)?;
-
-    Ok(w.into_inner())
+}
+
+fn generate_method(method: &Method) -> TokenStream {
+    let name = ident(&method.name.to_case(Case::Snake));
+    let maybe_req = method.request.clone().map(|r| ident(&r));
+    let maybe_resp = method.response.clone().map(|r| ident(&r));
+    match (maybe_req, maybe_resp) {
+        (Some(req), Some(resp)) => quote! {
+            pub fn #name (&mut self, req: & #req) -> Result<#resp, ZError> {
+                yunq::client::call_endpoint(req, &mut self.byte_buffer, self.endpoint_cap)
+            }
+        },
+        (Some(req), None) => quote! {
+            pub fn #name (&mut self, req: & #req) -> Result<yunq::message::Empty, ZError> {
+                yunq::client::call_endpoint(req, &mut self.byte_buffer, self.endpoint_cap)
+            }
+        },
+        (None, Some(resp)) => quote! {
+            pub fn #name (&mut self) -> Result<#resp, ZError> {
+                yunq::client::call_endpoint(&yunq::message::Empty{}, &mut self.byte_buffer, self.endpoint_cap)
+            }
+        },
+        _ => unreachable!(),
+    }
+}
+
+fn generate_interface(interface: &Interface) -> TokenStream {
+    let client_name = interface.name.clone() + "Client";
+    let name = ident(&client_name);
+    let methods = interface.methods.iter().map(|m| generate_method(&m));
+    quote! {
+        pub struct #name {
+            endpoint_cap: z_cap_t,
+            byte_buffer: ByteBuffer<0x1000>,
+        }
+
+        impl #name {
+            pub fn new(endpoint_cap: z_cap_t) -> Self {
+                Self {
+                    endpoint_cap,
+                    byte_buffer: ByteBuffer::new(),
+                }
+            }
+            #(#methods)*
+        }
+
+    }
+}
+
+pub fn generate_code(ast: &Vec<Decl>) -> String {
+    let prelude = quote! {
+    #![no_std]
+
+    extern crate alloc;
+
+    use alloc::string::String;
+    use alloc::string::ToString;
+    use mammoth::syscall::z_cap_t;
+    use mammoth::syscall::ZError;
+    use yunq::ByteBuffer;
+    use yunq::YunqMessage;
+    use yunq_derive::YunqMessage;
+    };
+
+    let message_decls = ast
+        .iter()
+        .filter_map(|decl| match decl {
+            Decl::Message(m) => Some(m),
+            _ => None,
+        })
+        .map(|message| generate_message(&message));
+
+    let interface_decls = ast
+        .iter()
+        .filter_map(|decl| match decl {
+            Decl::Interface(i) => Some(i),
+            _ => None,
+        })
+        .map(|interface| generate_interface(&interface));
+
+    let output = quote! {
+        #prelude
+
+        #(#message_decls)*
+
+        #(#interface_decls)*
+    }
+    .to_string();
+
+    prettyplease::unparse(&syn::parse_file(&output).unwrap())
 }

yunq/rust/src/main.rs

@@ -3,7 +3,7 @@ mod lexer;
 mod parser;
 
 use std::error::Error;
-use std::fs::read_to_string;
+use std::fs;
 
 use clap::Parser;
 
@@ -13,22 +13,24 @@ struct Args {
     // The .yunq file to parse
     #[arg(short, long)]
     input_path: String,
+
+    // The .rs file to generate
+    #[arg(short, long)]
+    output_path: String,
 }
 
 fn main() -> Result<(), Box<dyn Error>> {
     let args = Args::parse();
-    let input = read_to_string(args.input_path)?;
+    let input = fs::read_to_string(args.input_path)?;
     let tokens = lexer::lex_input(&input)?;
 
     let mut ast_parser = parser::Parser::new(&tokens);
     ast_parser.parse_ast()?;
     ast_parser.type_check()?;
 
-    for decl in ast_parser.ast() {
-        println!("{:?}", decl);
-    }
+    let code = codegen::generate_code(ast_parser.ast());
 
-    println!("{}", codegen::generate_code(ast_parser.ast())?);
+    fs::write(args.output_path, code)?;
 
     Ok(())
 }

yunq/rust/src/parser.rs

@@ -23,7 +23,7 @@ impl Type {
             Type::I64 => "i64",
             Type::String => "String",
             Type::Bytes => "Vec<u8>",
-            Type::Capability => "u64",
+            Type::Capability => "z_cap_t",
             Type::Message(s) => s,
         }
     }
@@ -102,8 +102,8 @@ impl Debug for Method {
 }
 
 pub struct Interface {
-    name: String,
-    methods: Vec<Method>,
+    pub name: String,
+    pub methods: Vec<Method>,
 }
 
 pub enum Decl {