rust/sys/denali/src/bin/denali.rs

@@ -27,6 +27,6 @@ extern "C" fn main() -> z_err_t {
 
     let thread = spawn_irq_thread(ahci_controller.clone());
 
-    thread.join().expect("Failed to wait on irq thread.");
+    thread.join();
     0
 }

rust/sys/yellowstone/src/server.rs

@@ -1,3 +1,6 @@
+use core::cell::RefCell;
+
+use alloc::rc::Rc;
 use alloc::sync::Arc;
 use alloc::{collections::BTreeMap, string::String};
 use mammoth::sync::Mutex;

yunq/rust/src/codegen.rs

@@ -152,7 +152,7 @@ fn parse_field(field: &Field) -> TokenStream {
                 unimplemented!();
             }
             Type::Message(s) => {
-                let m_type = ident(s);
+                let m_type = ident(&s);
                 quote! {
                     let #name = {
                         let msg_offset = buf.at::<u32>(yunq::message::field_offset(offset, #ind))? as usize;
@@ -272,7 +272,7 @@ fn generate_method(method: &Method) -> TokenStream {
 fn generate_client(interface: &Interface) -> TokenStream {
     let client_name = interface.name.clone() + "Client";
     let name = ident(&client_name);
-    let methods = interface.methods.iter().map(generate_method);
+    let methods = interface.methods.iter().map(|m| generate_method(&m));
     quote! {
         pub struct #name {
             endpoint_cap: Capability,
@@ -350,8 +350,8 @@ fn generate_server_method(method: &Method) -> TokenStream {
 fn generate_server(interface: &Interface) -> TokenStream {
     let server_name = ident(&(interface.name.clone() + "Server"));
     let server_trait = ident(&(interface.name.clone() + "ServerHandler"));
-    let server_trait_methods = interface.methods.iter().map(generate_server_method);
+    let server_trait_methods = interface.methods.iter().map(|m| generate_server_method(&m));
-    let server_match_cases = interface.methods.iter().map(generate_server_case);
+    let server_match_cases = interface.methods.iter().map(|m| generate_server_case(&m));
     quote! {
         pub trait #server_trait {
             #(#server_trait_methods)*
@@ -402,7 +402,7 @@ fn generate_interface(interface: &Interface) -> TokenStream {
     }
 }
 
-fn any_strings(ast: &[Decl]) -> bool {
+fn any_strings(ast: &Vec<Decl>) -> bool {
     ast.iter()
         .filter_map(|decl| match decl {
             Decl::Message(m) => Some(m),
@@ -412,11 +412,14 @@ fn any_strings(ast: &[Decl]) -> bool {
         .any(|field| field.field_type.inner_type == Type::String)
 }
 
-fn any_interfaces(ast: &[Decl]) -> bool {
+fn any_interfaces(ast: &Vec<Decl>) -> bool {
-    ast.iter().any(|decl| matches!(decl, Decl::Interface(_)))
+    ast.iter().any(|decl| match decl {
+        Decl::Interface(_) => true,
+        _ => false,
+    })
 }
 
-pub fn generate_code(ast: &[Decl]) -> String {
+pub fn generate_code(ast: &Vec<Decl>) -> String {
     let str_imports = if any_strings(ast) {
         quote! {
             use alloc::string::String;
@@ -428,8 +431,12 @@ pub fn generate_code(ast: &[Decl]) -> String {
 
     let interface_imports = if any_interfaces(ast) {
         quote! {
+            use alloc::boxed::Box;
+            use core::ffi::c_void;
             use mammoth::cap::Capability;
             use mammoth::syscall;
+            use mammoth::thread;
+            use yunq::server::YunqServer;
         }
     } else {
         quote! {}
@@ -457,7 +464,7 @@ pub fn generate_code(ast: &[Decl]) -> String {
             Decl::Message(m) => Some(m),
             _ => None,
         })
-        .map(generate_message);
+        .map(|message| generate_message(&message));
 
     let interface_decls = ast
         .iter()
@@ -465,7 +472,7 @@ pub fn generate_code(ast: &[Decl]) -> String {
             Decl::Interface(i) => Some(i),
             _ => None,
         })
-        .map(generate_interface);
+        .map(|interface| generate_interface(&interface));
 
     let output = quote! {
         #prelude

yunq/rust/src/parser.rs

@@ -169,7 +169,7 @@ impl<'a> Parser<'a> {
             && self.tokens[self.current_index].token_type == tok_type
     }
 
-    fn consume_token(&mut self) -> &Token {
+    fn consume_token<'b>(&'b mut self) -> &'b Token {
         if self.current_index >= self.tokens.len() {
             panic!("Consumed tokens past end of input.")
         }
@@ -179,7 +179,7 @@ impl<'a> Parser<'a> {
         t
     }
 
-    fn consume_token_type(&mut self, t: TokenType) -> Result<&Token, String> {
+    fn consume_token_type<'b>(&'b mut self, t: TokenType) -> Result<&'b Token, String> {
         let token = self.consume_token();
         if token.token_type == t {
             Ok(token)
@@ -188,7 +188,7 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn consume_identifier(&mut self) -> Result<&Token, String> {
+    fn consume_identifier<'b>(&'b mut self) -> Result<&'b Token, String> {
         self.consume_token_type(TokenType::Name)
     }