diff --git a/.forgejo/workflows/ci.yml b/.forgejo/workflows/ci.yml new file mode 100644 index 0000000..7609116 --- /dev/null +++ b/.forgejo/workflows/ci.yml @@ -0,0 +1,46 @@ +name: Check + +on: + push: + branches: [main] + pull_request: + branches: [main] + +env: + # Should speed up builds. + CARGO_INCREMENTAL: 0 + # Should reduce the size of ./target to improve cache load/store. + CARGO_PROFILE_TEST_DEBUG: 0 + +jobs: + check: + name: Check Rust + runs-on: docker + + steps: + - name: Checkout Repo + uses: actions/checkout@v4 + + - name: Install Rust + uses: https://codeberg.org/wackbyte/rust-toolchain@trunk + with: + toolchain: nightly-2025-10-02 + components: rustfmt, clippy, rust-src + - name: Cache + uses: https://github.com/Swatinem/rust-cache@v2 + with: + # Don't cache ~/.cargo/bin since we restore the cache after we install things there + cache-bin: "false" + workspaces: "backend" + - name: "Check Format" + run: cargo fmt --check + working-directory: rust + - name: "Build" + run: | + cargo build --tests --locked + working-directory: rust + - name: "Lint" + run: | + rustup component add clippy + cargo clippy --locked -- -D warnings + working-directory: rust diff --git a/rust-toolchain.toml b/rust-toolchain.toml index 66768f4..f7acab6 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -1,3 +1,3 @@ [toolchain] channel = "nightly-2025-10-02" -components = ["rustfmt", "rust-analyzer"] +components = ["rustfmt", "rust-analyzer", "clippy", "rust-src"] diff --git a/rust/lib/fs/ext2/src/ext2_driver.rs b/rust/lib/fs/ext2/src/ext2_driver.rs index 96bb858..0997b62 100644 --- a/rust/lib/fs/ext2/src/ext2_driver.rs +++ b/rust/lib/fs/ext2/src/ext2_driver.rs @@ -94,7 +94,7 @@ impl Ext2Driver { /// Updates the cached inode tables to contain the inode table for /// a specific group. fn populate_inode_table_if_none(&mut self, block_group_num: usize) { - if let None = self.inode_table_map[block_group_num] { + if self.inode_table_map[block_group_num].is_none() { debug!( "Cache MISS on inode table for block_group {}", block_group_num @@ -148,17 +148,15 @@ impl Ext2Driver { let dbl_indr_block_mem = MemoryRegion::from_cap(self.reader.read(block_num, 1).unwrap()).unwrap(); - let dbl_indr_blocks: &[u32] = dbl_indr_block_mem.slice(); + let dbl_indr_blocks: &[u32] = &dbl_indr_block_mem.slice()[0..num_dbl_indr]; let mut blocks_to_read = Vec::new(); - for i in 0..num_dbl_indr { + for (i, dbl_indr_block) in dbl_indr_blocks.iter().enumerate() { let num_blocks_in_single = min(num_blocks - (256 * i), 256); blocks_to_read.append( - &mut self.get_blocks_from_single_indirect( - dbl_indr_blocks[i] as u64, - num_blocks_in_single, - ), + &mut self + .get_blocks_from_single_indirect(*dbl_indr_block as u64, num_blocks_in_single), ); } @@ -176,7 +174,7 @@ impl Ext2Driver { let mut blocks = Vec::new(); - while let Some(block) = iter.next() { + for block in iter { if block as u64 == (curr_block.lba + curr_block.size) { curr_block.size += 1; } else { diff --git a/rust/lib/fs/ext2/src/types.rs b/rust/lib/fs/ext2/src/types.rs index 7aa3d2b..fd1f59b 100644 --- a/rust/lib/fs/ext2/src/types.rs +++ b/rust/lib/fs/ext2/src/types.rs @@ -111,7 +111,9 @@ pub struct Inode { const _: () = assert!(size_of::() == 128); +#[allow(dead_code)] pub const EXT2_FT_FILE: u8 = 0x1; +#[allow(dead_code)] pub const EXT2_FT_DIR: u8 = 0x2; #[repr(C, packed)] diff --git a/rust/lib/mammoth/src/cap_syscall.rs b/rust/lib/mammoth/src/cap_syscall.rs index eb9567a..b820bdc 100644 --- a/rust/lib/mammoth/src/cap_syscall.rs +++ b/rust/lib/mammoth/src/cap_syscall.rs @@ -2,7 +2,6 @@ use core::ffi::c_void; use crate::zion::{self, z_cap_t, ZError}; -#[must_use] fn syscall(id: u64, req: &T) -> Result<(), ZError> { unsafe { let resp = zion::SysCall1(id, req as *const T as *const c_void); diff --git a/rust/lib/mammoth/src/elf.rs b/rust/lib/mammoth/src/elf.rs index 2b8638f..96807d2 100644 --- a/rust/lib/mammoth/src/elf.rs +++ b/rust/lib/mammoth/src/elf.rs @@ -1,5 +1,4 @@ use crate::cap::Capability; -use crate::debug; use crate::init; use crate::syscall; use crate::zion::ZError; @@ -237,7 +236,7 @@ fn load_program_segment( let page_offset = prog_header.vaddr & 0xFFF; let mem_size = page_offset + prog_header.mem_size; - let mem_object = crate::mem::MemoryRegion::new(mem_size)?; + let mut mem_object = crate::mem::MemoryRegion::new(mem_size)?; for i in mem_object.mut_slice() { *i = 0; diff --git a/rust/lib/mammoth/src/init.rs b/rust/lib/mammoth/src/init.rs index 556cf24..c190ad1 100644 --- a/rust/lib/mammoth/src/init.rs +++ b/rust/lib/mammoth/src/init.rs @@ -28,7 +28,7 @@ pub fn parse_init_port(port_cap: z_cap_t) { let mut caps: [u64; 1] = [0]; let resp = syscall::port_poll(&init_port, &mut bytes, &mut caps); - if let Err(_) = resp { + if resp.is_err() { break; } diff --git a/rust/lib/mammoth/src/macros.rs b/rust/lib/mammoth/src/macros.rs index c977a91..3fc64c5 100644 --- a/rust/lib/mammoth/src/macros.rs +++ b/rust/lib/mammoth/src/macros.rs @@ -2,21 +2,20 @@ use alloc::string::String; use alloc::vec::Vec; use core::fmt; +#[derive(Default)] pub struct Writer { int_vec: Vec, } impl Writer { pub fn new() -> Self { - Self { - int_vec: Vec::new(), - } + Writer::default() } } -impl Into for Writer { - fn into(self) -> String { - String::from_utf8(self.int_vec).expect("Failed to convert") +impl From for String { + fn from(value: Writer) -> Self { + String::from_utf8(value.int_vec).expect("Failed to convert") } } diff --git a/rust/lib/mammoth/src/mem.rs b/rust/lib/mammoth/src/mem.rs index 8d5af40..90183ec 100644 --- a/rust/lib/mammoth/src/mem.rs +++ b/rust/lib/mammoth/src/mem.rs @@ -85,7 +85,7 @@ impl MemoryRegion { } } - pub fn mut_slice(&self) -> &mut [T] { + pub fn mut_slice(&mut self) -> &mut [T] { unsafe { slice::from_raw_parts_mut( self.virt_addr as *mut T, diff --git a/rust/lib/mammoth/src/sync.rs b/rust/lib/mammoth/src/sync.rs index 0ee5fea..f435e32 100644 --- a/rust/lib/mammoth/src/sync.rs +++ b/rust/lib/mammoth/src/sync.rs @@ -50,7 +50,7 @@ impl DerefMut for MutexGuard<'_, T> { } } -impl Mutex { +impl<'a, T> Mutex { pub fn new(data: T) -> Mutex { Mutex { cap: syscall::mutex_create().unwrap(), @@ -58,7 +58,7 @@ impl Mutex { } } - pub fn lock(&self) -> MutexGuard { + pub fn lock(&'a self) -> MutexGuard<'a, T> { syscall::mutex_lock(&self.cap).unwrap(); MutexGuard { mutex: self } @@ -70,3 +70,12 @@ impl Drop for MutexGuard<'_, T> { syscall::mutex_release(&self.mutex.cap).unwrap(); } } + +impl Default for Mutex +where + T: Default, +{ + fn default() -> Self { + Self::new(T::default()) + } +} diff --git a/rust/lib/mammoth/src/syscall.rs b/rust/lib/mammoth/src/syscall.rs index 2691458..bab76ca 100644 --- a/rust/lib/mammoth/src/syscall.rs +++ b/rust/lib/mammoth/src/syscall.rs @@ -9,7 +9,6 @@ use core::ffi::c_void; #[cfg(feature = "hosted")] use core::panic::PanicInfo; -#[must_use] fn syscall(id: u64, req: &T) -> Result<(), ZError> { unsafe { let resp = zion::SysCall1(id, req as *const T as *const c_void); diff --git a/rust/lib/mammoth/src/task/mod.rs b/rust/lib/mammoth/src/task/mod.rs index 44aab69..ec25afa 100644 --- a/rust/lib/mammoth/src/task/mod.rs +++ b/rust/lib/mammoth/src/task/mod.rs @@ -48,7 +48,7 @@ struct TaskWaker { } impl TaskWaker { - fn new(task_id: TaskId, task_queue: Arc>>) -> Waker { + fn create_waker(task_id: TaskId, task_queue: Arc>>) -> Waker { Waker::from(Arc::new(TaskWaker { task_id, task_queue, @@ -69,6 +69,7 @@ impl Wake for TaskWaker { } } +#[derive(Default)] pub struct Executor { tasks: Arc>>, // TODO: Consider a better datastructure for this. @@ -78,11 +79,7 @@ pub struct Executor { impl Executor { pub fn new() -> Executor { - Executor { - tasks: Arc::new(Mutex::new(BTreeMap::new())), - task_queue: Arc::new(Mutex::new(VecDeque::new())), - waker_cache: BTreeMap::new(), - } + Executor::default() } pub fn spawn(&mut self, task: Task) { @@ -100,7 +97,7 @@ impl Executor { let waker = self .waker_cache .entry(task_id) - .or_insert_with(|| TaskWaker::new(task_id, self.task_queue.clone())); + .or_insert_with(|| TaskWaker::create_waker(task_id, self.task_queue.clone())); let mut ctx = Context::from_waker(waker); match task.poll(&mut ctx) { Poll::Ready(()) => { diff --git a/rust/lib/mammoth/src/thread.rs b/rust/lib/mammoth/src/thread.rs index 99032be..aeb4b27 100644 --- a/rust/lib/mammoth/src/thread.rs +++ b/rust/lib/mammoth/src/thread.rs @@ -40,7 +40,7 @@ where let raw_main = Box::into_raw(Box::new(main)); let proc_cap = Capability::take_copy(unsafe { crate::init::SELF_PROC_CAP }).unwrap(); let cap = syscall::thread_create(&proc_cap).unwrap(); - syscall::thread_start(&cap, entry_point as u64, raw_main as u64, 0).unwrap(); + syscall::thread_start(&cap, entry_point as usize as u64, raw_main as u64, 0).unwrap(); JoinHandle { cap } } diff --git a/rust/lib/pci/src/device.rs b/rust/lib/pci/src/device.rs index ab1b25d..e65e3da 100644 --- a/rust/lib/pci/src/device.rs +++ b/rust/lib/pci/src/device.rs @@ -2,8 +2,7 @@ use alloc::vec::Vec; use mammoth::{cap::Capability, mem::MemoryRegion, syscall, zion::ZError}; use crate::header::{ - PciCapabilityPointer, PciDeviceHeader, PciHeaderType, PciMsiCapability, PciMsiControl, - get_header_type, + PciCapabilityPointer, PciDeviceHeader, PciHeaderType, PciMsiCapability, get_header_type, }; pub struct PciDevice { @@ -11,7 +10,7 @@ pub struct PciDevice { } impl PciDevice { - pub fn from(mut memory_region: MemoryRegion) -> Result { + pub fn from(memory_region: MemoryRegion) -> Result { match get_header_type(&memory_region)? { PciHeaderType::Device => {} t => { diff --git a/rust/lib/voyageurs/src/listener.rs b/rust/lib/voyageurs/src/listener.rs index 1912b88..89e40b6 100644 --- a/rust/lib/voyageurs/src/listener.rs +++ b/rust/lib/voyageurs/src/listener.rs @@ -7,7 +7,7 @@ use mammoth::thread; #[allow(dead_code)] #[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone)] enum Keycode { - UnknownKeycode = 0x0, + Unknown = 0x0, A = 0x1, B = 0x2, @@ -135,7 +135,7 @@ impl Keycode { 0x37 => Keycode::Period, 0x38 => Keycode::FSlash, 0x39 => Keycode::Esc, - _ => Keycode::UnknownKeycode, + _ => Keycode::Unknown, } } } diff --git a/rust/lib/yellowstone/src/lib.rs b/rust/lib/yellowstone/src/lib.rs index 76659ef..ffdc267 100644 --- a/rust/lib/yellowstone/src/lib.rs +++ b/rust/lib/yellowstone/src/lib.rs @@ -10,10 +10,12 @@ static mut YELLOWSTONE_INIT: Option = None; pub fn from_init_endpoint() -> &'static mut YellowstoneClient { unsafe { - if let None = YELLOWSTONE_INIT { + #[allow(static_mut_refs)] + if YELLOWSTONE_INIT.is_none() { YELLOWSTONE_INIT = Some(YellowstoneClient::new(Capability::take(INIT_ENDPOINT))); } + #[allow(static_mut_refs)] YELLOWSTONE_INIT.as_mut().unwrap() } } diff --git a/rust/lib/yunq-test/src/lib.rs b/rust/lib/yunq-test/src/lib.rs index 1a3c3ec..9af3d55 100644 --- a/rust/lib/yunq-test/src/lib.rs +++ b/rust/lib/yunq-test/src/lib.rs @@ -12,7 +12,11 @@ mod tests { #[test] fn basic_serialization() -> Result<(), ZError> { - let basic = Basic { unsigned_int: 82, signed_int: -1234, strn: "abc".to_string() }; + let basic = Basic { + unsigned_int: 82, + signed_int: -1234, + strn: "abc".to_string(), + }; let mut buf = ByteBuffer::<1024>::new(); let mut caps = Vec::new(); @@ -27,13 +31,17 @@ mod tests { #[test] fn basic_serialization_as_request() -> Result<(), ZError> { - let basic = Basic { unsigned_int: 82, signed_int: -1234, strn: "abc".to_string() }; + let basic = Basic { + unsigned_int: 82, + signed_int: -1234, + strn: "abc".to_string(), + }; let mut buf = ByteBuffer::<1024>::new(); let mut caps = Vec::new(); let req_id = 12; basic.serialize_as_request(req_id, &mut buf, &mut caps)?; - + assert!(buf.at::(8)? == req_id); let parsed = Basic::parse_from_request(&buf, &caps)?; @@ -50,7 +58,7 @@ mod tests { let mut buf = ByteBuffer::<1024>::new(); let mut caps = Vec::new(); cap.serialize(&mut buf, 0, &mut caps)?; - + assert!(caps.len() == 1); assert!(caps[0] == cap_id); @@ -63,12 +71,14 @@ mod tests { #[test] fn repeated_serialization() -> Result<(), ZError> { - let rep = Repeated { unsigned_ints: vec![0, 1, 3],}; + let rep = Repeated { + unsigned_ints: vec![0, 1, 3], + }; let mut buf = ByteBuffer::<1024>::new(); let mut caps = Vec::new(); rep.serialize(&mut buf, 0, &mut caps)?; - + let parsed = Repeated::parse(&buf, 0, &caps)?; assert!(parsed == rep); @@ -79,17 +89,20 @@ mod tests { #[test] fn nested_serialization() -> Result<(), ZError> { let nested = Nested { - basic: Basic { unsigned_int: 82, signed_int: -1234, strn: "abc".to_string() }, - cap1: Cap { cap: 37}, - cap2: Cap { cap: 39}, + basic: Basic { + unsigned_int: 82, + signed_int: -1234, + strn: "abc".to_string(), + }, + cap1: Cap { cap: 37 }, + cap2: Cap { cap: 39 }, }; let mut buf = ByteBuffer::<1024>::new(); let mut caps = Vec::new(); nested.serialize(&mut buf, 0, &mut caps)?; - - let parsed = Nested::parse(&buf, 0, &caps)?; + let parsed = Nested::parse(&buf, 0, &caps)?; assert!(parsed == nested); @@ -99,23 +112,29 @@ mod tests { #[test] fn repeated_nested_serialization() -> Result<(), ZError> { let nested = RepeatedNested { - basics: vec![Basic { unsigned_int: 82, signed_int: -1234, strn: "abc".to_string(),}, - Basic { unsigned_int: 21, signed_int: -8, strn: "def".to_string(), },], - caps: vec![Cap{ cap: 123}, Cap {cap: 12343}], + basics: vec![ + Basic { + unsigned_int: 82, + signed_int: -1234, + strn: "abc".to_string(), + }, + Basic { + unsigned_int: 21, + signed_int: -8, + strn: "def".to_string(), + }, + ], + caps: vec![Cap { cap: 123 }, Cap { cap: 12343 }], }; let mut buf = ByteBuffer::<1024>::new(); let mut caps = Vec::new(); nested.serialize(&mut buf, 0, &mut caps)?; - - let parsed = RepeatedNested::parse(&buf, 0, &caps)?; + let parsed = RepeatedNested::parse(&buf, 0, &caps)?; assert!(parsed == nested); - Ok(()) } - - } diff --git a/rust/lib/yunq/src/buffer.rs b/rust/lib/yunq/src/buffer.rs index c3b0b18..7966337 100644 --- a/rust/lib/yunq/src/buffer.rs +++ b/rust/lib/yunq/src/buffer.rs @@ -5,12 +5,19 @@ pub struct ByteBuffer { buffer: Box<[u8; N]>, } -impl ByteBuffer { - pub fn new() -> Self { +impl Default for ByteBuffer { + fn default() -> Self { Self { buffer: Box::new([0; N]), } } +} + +impl ByteBuffer { + pub fn new() -> Self { + ByteBuffer::default() + } + pub fn size(&self) -> u64 { N as u64 } @@ -54,7 +61,7 @@ impl ByteBuffer { if (len + offset) > N { return Err(ZError::BUFFER_SIZE); } - Ok(alloc::str::from_utf8(&self.buffer[offset..offset + len]) - .map_err(|_| ZError::INVALID_ARGUMENT)?) + alloc::str::from_utf8(&self.buffer[offset..offset + len]) + .map_err(|_| ZError::INVALID_ARGUMENT) } } diff --git a/rust/lib/yunq/src/client.rs b/rust/lib/yunq/src/client.rs index e90698e..c4c45b8 100644 --- a/rust/lib/yunq/src/client.rs +++ b/rust/lib/yunq/src/client.rs @@ -34,5 +34,5 @@ pub fn call_endpoint( return Err(ZError::from(resp_code)); } - Ok(Resp::parse_from_request(&byte_buffer, &cap_buffer)?) + Resp::parse_from_request(byte_buffer, &cap_buffer) } diff --git a/rust/lib/yunq/src/message.rs b/rust/lib/yunq/src/message.rs index d1fc6a5..568916f 100644 --- a/rust/lib/yunq/src/message.rs +++ b/rust/lib/yunq/src/message.rs @@ -28,7 +28,7 @@ pub fn parse_repeated_message( buf: &ByteBuffer, mut offset: usize, len: usize, - caps: &Vec, + caps: &[z_cap_t], ) -> Result, ZError> { let mut repeated = Vec::new(); for _ in 0..len { @@ -43,18 +43,18 @@ pub fn parse_repeated_message( pub fn serialize_repeated( buf: &mut ByteBuffer, offset: usize, - data: &Vec, + data: &[T], ) -> Result { - for i in 0..data.len() { - buf.write_at(offset + (i * size_of::()), data[i])?; + for (i, val) in data.iter().enumerate() { + buf.write_at(offset + (i * size_of::()), val)?; } - Ok(offset + (data.len() * size_of::())) + Ok(offset + size_of_val(data)) } pub fn serialize_repeated_message( buf: &mut ByteBuffer, mut offset: usize, - data: &Vec, + data: &[T], caps: &mut Vec, ) -> Result { for item in data { @@ -76,14 +76,14 @@ pub trait YunqMessage { fn parse( buf: &ByteBuffer, offset: usize, - caps: &Vec, + caps: &[z_cap_t], ) -> Result where Self: Sized; fn parse_from_request( buf: &ByteBuffer, - caps: &Vec, + caps: &[z_cap_t], ) -> Result where Self: Sized, @@ -92,7 +92,7 @@ pub trait YunqMessage { return Err(ZError::INVALID_RESPONSE); } - Ok(Self::parse(&buf, 16, &caps)?) + Self::parse(buf, 16, caps) } fn serialize( @@ -109,7 +109,7 @@ pub trait YunqMessage { caps: &mut Vec, ) -> Result { buf.write_at(0, SENTINEL)?; - buf.write_at(8, request_id as u64)?; + buf.write_at(8, request_id)?; let length = self.serialize(buf, 16, caps)?; @@ -125,7 +125,7 @@ impl YunqMessage for Empty { fn parse( _buf: &ByteBuffer, _offset: usize, - _caps: &Vec, + _caps: &[z_cap_t], ) -> Result where Self: Sized, diff --git a/rust/lib/yunq/src/server.rs b/rust/lib/yunq/src/server.rs index a5ded0b..cdfe418 100644 --- a/rust/lib/yunq/src/server.rs +++ b/rust/lib/yunq/src/server.rs @@ -37,7 +37,7 @@ pub trait YunqServer { .expect("Failed to reply"), Err(err) => { crate::message::serialize_error(&mut byte_buffer, err); - syscall::reply_port_send(reply_port_cap, &byte_buffer.slice(0x10), &[]) + syscall::reply_port_send(reply_port_cap, byte_buffer.slice(0x10), &[]) .expect("Failed to reply w/ error") } } @@ -84,11 +84,11 @@ where .at::(8) .expect("Failed to access request length."); let self_clone = self.clone(); - spawner.spawn(Task::new((async move || { + spawner.spawn(Task::new(async move { self_clone .handle_request_and_response(method, byte_buffer, cap_buffer, reply_port_cap) - .await; - })())); + .await + })); } } @@ -113,12 +113,10 @@ where .expect("Failed to reply"), Err(err) => { crate::message::serialize_error(&mut byte_buffer, err); - syscall::reply_port_send(reply_port_cap, &byte_buffer.slice(0x10), &[]) + syscall::reply_port_send(reply_port_cap, byte_buffer.slice(0x10), &[]) .expect("Failed to reply w/ error") } } - - () } } diff --git a/rust/sys/denali/src/ahci/command.rs b/rust/sys/denali/src/ahci/command.rs index 947082e..c827bb1 100644 --- a/rust/sys/denali/src/ahci/command.rs +++ b/rust/sys/denali/src/ahci/command.rs @@ -95,7 +95,7 @@ impl Command { command: SataCommand::DmaReadExt, lba, sector_cnt: lba_count, - paddr: paddr, + paddr, memory_region: None, } } diff --git a/rust/sys/denali/src/ahci/port_controller.rs b/rust/sys/denali/src/ahci/port_controller.rs index 556e8f7..42dfa00 100644 --- a/rust/sys/denali/src/ahci/port_controller.rs +++ b/rust/sys/denali/src/ahci/port_controller.rs @@ -44,9 +44,8 @@ impl PortController { }; // This leaves space for 8 prdt entries. - for i in 0..32 { - command_list[i].command_table_base_addr = - (command_paddr + 0x500) + (0x100 * (i as u64)); + for (i, header) in command_list.iter_mut().enumerate() { + header.command_table_base_addr = (command_paddr + 0x500) + (0x100 * (i as u64)); } let command_slots = array::from_fn(|_| Arc::new(Mutex::new(CommandStatus::Empty))); diff --git a/rust/sys/teton/src/framebuffer.rs b/rust/sys/teton/src/framebuffer.rs index dad4099..f083367 100644 --- a/rust/sys/teton/src/framebuffer.rs +++ b/rust/sys/teton/src/framebuffer.rs @@ -16,15 +16,16 @@ impl Framebuffer { }) } - fn draw_pixel(&self, row: u32, col: u32, pixel: u32) { + fn draw_pixel(&mut self, row: u32, col: u32, pixel: u32) { let index = row * (self.fb_info.pitch as u32 / 4) + col; self.memory_region.mut_slice()[index as usize] = pixel; } - pub fn draw_glyph(&self, glyph: &[u8], row: u32, col: u32) { + pub fn draw_glyph(&mut self, glyph: &[u8], row: u32, col: u32) { let gl_width = 8; let gl_height = 16; + #[allow(clippy::needless_range_loop)] for r in 0..gl_height { for c in 0..gl_width { if ((glyph[r] >> c) % 2) == 1 { diff --git a/rust/sys/teton/src/psf.rs b/rust/sys/teton/src/psf.rs index f6a75a6..3f99f65 100644 --- a/rust/sys/teton/src/psf.rs +++ b/rust/sys/teton/src/psf.rs @@ -23,7 +23,7 @@ pub struct Psf { impl Psf { pub fn new(path: &str) -> Result { - let file = File::open(&path)?; + let file = File::open(path)?; let header = file.slice()[0..core::mem::size_of::()] .as_ptr() diff --git a/rust/sys/teton/src/terminal.rs b/rust/sys/teton/src/terminal.rs index 5c7d314..f8a9e0f 100644 --- a/rust/sys/teton/src/terminal.rs +++ b/rust/sys/teton/src/terminal.rs @@ -62,10 +62,8 @@ impl Terminal { } fn write_line(&mut self, line: &str) { - let mut col = 0; - for c in line.chars() { - self.console.write_char(c, self.row, col); - col += 1; + for (col, c) in line.chars().enumerate() { + self.console.write_char(c, self.row, col as u32); } self.row += 1 diff --git a/rust/sys/victoriafalls/src/lib.rs b/rust/sys/victoriafalls/src/lib.rs index b7b9ca3..a213a8b 100644 --- a/rust/sys/victoriafalls/src/lib.rs +++ b/rust/sys/victoriafalls/src/lib.rs @@ -12,7 +12,8 @@ static mut VFS_CLIENT: Option = None; fn get_client() -> &'static mut VFSClient { unsafe { - if let None = VFS_CLIENT { + #[allow(static_mut_refs)] + if VFS_CLIENT.is_none() { let endpoint_cap = yellowstone_yunq::from_init_endpoint() .get_endpoint(&yellowstone_yunq::GetEndpointRequest { endpoint_name: "victoriafalls".to_string(), @@ -21,6 +22,7 @@ fn get_client() -> &'static mut VFSClient { VFS_CLIENT = Some(VFSClient::new(Capability::take(endpoint_cap.endpoint))); } + #[allow(static_mut_refs)] VFS_CLIENT.as_mut().unwrap() } } diff --git a/rust/sys/victoriafalls/src/server.rs b/rust/sys/victoriafalls/src/server.rs index 0c2edb8..a901ea9 100644 --- a/rust/sys/victoriafalls/src/server.rs +++ b/rust/sys/victoriafalls/src/server.rs @@ -35,7 +35,7 @@ impl VFSServerHandler for VictoriaFallsServerImpl { let mut inode_num = 2; // Start with root. - while let Some(path_token) = tokens.next() { + for path_token in tokens { inode_num = self.find_path_in_dir(inode_num, path_token)?; } @@ -57,7 +57,7 @@ impl VFSServerHandler for VictoriaFallsServerImpl { let mut inode_num = 2; // Start with root. - while let Some(path_token) = tokens.next() { + for path_token in tokens { inode_num = self.find_path_in_dir(inode_num, path_token)?; } diff --git a/rust/sys/yellowstone/src/server.rs b/rust/sys/yellowstone/src/server.rs index 8cc4a4b..a6d5fa1 100644 --- a/rust/sys/yellowstone/src/server.rs +++ b/rust/sys/yellowstone/src/server.rs @@ -57,9 +57,8 @@ impl YellowstoneServerContext { pub fn wait(&self, service: &str) -> Result<(), ZError> { loop { - match self.service_map.lock().get(service) { - Some(_) => return Ok(()), - None => {} + if self.service_map.lock().get(service).is_some() { + return Ok(()); } self.registration_semaphore.wait().unwrap(); } diff --git a/yunq/rust/src/codegen.rs b/yunq/rust/src/codegen.rs index 7eefb66..9462f4b 100644 --- a/yunq/rust/src/codegen.rs +++ b/yunq/rust/src/codegen.rs @@ -122,7 +122,7 @@ fn parse_field(field: &Field) -> TokenStream { let rep_offset = buf.at::(yunq::message::field_offset(offset, #ind))?; let rep_len = buf.at::(yunq::message::field_offset(offset, #ind) + 4)?; - yunq::message::parse_repeated_message(buf, offset + rep_offset as usize, rep_len as usize, &caps)? + yunq::message::parse_repeated_message(buf, offset + rep_offset as usize, rep_len as usize, caps)? }; }, } @@ -174,7 +174,7 @@ fn generate_serialize(message: &Message) -> TokenStream { &self, buf: &mut yunq::ByteBuffer, offset: usize, - caps: &mut alloc::vec::Vec, + caps: &mut Vec, ) -> Result { let num_fields = #num_fields; let core_size: u32 = (yunq::message::MESSAGE_HEADER_SIZE + 8 * num_fields) as u32; @@ -183,10 +183,10 @@ fn generate_serialize(message: &Message) -> TokenStream { #(#serializers)* - buf.write_at(offset + 0, yunq::message::MESSAGE_IDENT)?; + buf.write_at(offset, yunq::message::MESSAGE_IDENT)?; buf.write_at(offset + 4, core_size)?; buf.write_at(offset + 8, next_extension)?; - buf.write_at(offset + 12, 0 as u32)?; + buf.write_at(offset + 12, 0_u32)?; Ok(next_extension as usize) } } @@ -200,12 +200,12 @@ fn generate_parse(message: &Message) -> TokenStream { fn parse( buf: &yunq::ByteBuffer, offset: usize, - caps: &alloc::vec::Vec, + caps: &[z_cap_t], ) -> Result where Self: Sized, { - if buf.at::(offset + 0)? != yunq::message::MESSAGE_IDENT { + if buf.at::(offset)? != yunq::message::MESSAGE_IDENT { mammoth::debug!("Expected IDENT at offest {:#x}, got {:#x}", offset, buf.at::(offset)?); return Err(ZError::INVALID_ARGUMENT); } @@ -303,7 +303,7 @@ fn generate_server_case(method: &Method) -> TokenStream { #id => { let req = #req::parse_from_request(byte_buffer, cap_buffer)?; let resp = self.handler.#name(req)?; - cap_buffer.resize(0, 0); + cap_buffer.clear(); let resp_len = resp.serialize_as_request(0, byte_buffer, cap_buffer)?; Ok(resp_len) }, @@ -312,7 +312,7 @@ fn generate_server_case(method: &Method) -> TokenStream { #id => { let req = #req::parse_from_request(byte_buffer, cap_buffer)?; self.handler.#name(req)?; - cap_buffer.resize(0, 0); + cap_buffer.clear(); // TODO: Implement serialization for EmptyMessage so this is less hacky. yunq::message::serialize_error(byte_buffer, ZError::from(0)); Ok(0x10) @@ -321,7 +321,7 @@ fn generate_server_case(method: &Method) -> TokenStream { (None, Some(_)) => quote! { #id => { let resp = self.handler.#name()?; - cap_buffer.resize(0, 0); + cap_buffer.clear(); let resp_len = resp.serialize_as_request(0, byte_buffer, cap_buffer)?; Ok(resp_len) }, @@ -403,7 +403,7 @@ fn generate_async_server_case(method: &Method) -> TokenStream { #id => { let req = #req::parse_from_request(byte_buffer, cap_buffer)?; let resp = self.handler.#name(req).await?; - cap_buffer.resize(0, 0); + cap_buffer.clear(); let resp_len = resp.serialize_as_request(0, byte_buffer, cap_buffer)?; Ok(resp_len) }, @@ -412,7 +412,7 @@ fn generate_async_server_case(method: &Method) -> TokenStream { #id => { let req = #req::parse_from_request(byte_buffer, cap_buffer)?; self.handler.#name(req).await?; - cap_buffer.resize(0, 0); + cap_buffer.clear(); // TODO: Implement serialization for EmptyMessage so this is less hacky. yunq::message::serialize_error(byte_buffer, ZError::from(0)); Ok(0x10) @@ -421,7 +421,7 @@ fn generate_async_server_case(method: &Method) -> TokenStream { (None, Some(_)) => quote! { #id => { let resp = self.handler.#name().await?; - cap_buffer.resize(0, 0); + cap_buffer.clear(); let resp_len = resp.serialize_as_request(0, byte_buffer, cap_buffer)?; Ok(resp_len) }, @@ -547,6 +547,7 @@ pub fn generate_code(ast: &[Decl]) -> String { use alloc::vec::Vec; use mammoth::zion::z_cap_t; use mammoth::zion::ZError; + #[allow(unused_imports)] use yunq::ByteBuffer; use yunq::YunqMessage;