Fix easy clippy warnings

Author: IsaacWoods

src/aml/mod.rs

@@ -112,7 +112,7 @@ where
                     table.length as usize - mem::size_of::<SdtHeader>(),
                 )
             };
-            interpreter.load_table(stream).map_err(|err| AcpiError::Aml(err))?;
+            interpreter.load_table(stream).map_err(AcpiError::Aml)?;
             Ok(())
         }
 
@@ -308,7 +308,7 @@ where
                     Opcode::Increment | Opcode::Decrement => {
                         let [Argument::Object(operand)] = &op.arguments[..] else { panic!() };
                         let token = self.object_token.lock();
-                        let Object::Integer(operand) = (unsafe { operand.gain_mut(&*token) }) else {
+                        let Object::Integer(operand) = (unsafe { operand.gain_mut(&token) }) else {
                             Err(AmlError::ObjectNotOfExpectedType {
                                 expected: ObjectType::Integer,
                                 got: operand.typ(),
@@ -564,7 +564,7 @@ where
                     }
                     Opcode::Store => {
                         let [Argument::Object(object), target] = &op.arguments[..] else { panic!() };
-                        self.do_store(&target, object.clone())?;
+                        self.do_store(target, object.clone())?;
                         context.retire_op(op);
                     }
                     Opcode::RefOf => {
@@ -788,7 +788,7 @@ where
                             }
                         }
                         BlockKind::Scope { old_scope } => {
-                            assert!(context.block_stack.len() > 0);
+                            assert!(!context.block_stack.is_empty());
                             context.current_block = context.block_stack.pop().unwrap();
                             context.current_scope = old_scope;
                             // Go round the loop again to get the next opcode for the new block
@@ -804,7 +804,7 @@ where
                              * *distinct* uninitialized objects, and go round again to complete the
                              * in-flight op.
                              */
-                            assert!(context.block_stack.len() > 0);
+                            assert!(!context.block_stack.is_empty());
 
                             if let Some(package_op) = context.in_flight.last_mut()
                                 && (package_op.op == Opcode::Package || package_op.op == Opcode::VarPackage)
@@ -1626,7 +1626,7 @@ where
                  * Apparently, the NT interpreter always uses the first 8 bytes of the buffer.
                  */
                 let mut to_interpret = [0u8; 8];
-                (to_interpret[0..usize::min(bytes.len(), 8)]).copy_from_slice(&bytes);
+                (to_interpret[0..usize::min(bytes.len(), 8)]).copy_from_slice(bytes);
                 Object::Integer(u64::from_le_bytes(to_interpret))
             }
             Object::String(ref value) => {
@@ -1642,8 +1642,9 @@ where
                     })?;
                     Object::Integer(parsed)
                 } else {
-                    let parsed = u64::from_str_radix(value, 10).map_err(|_| {
-                        AmlError::InvalidOperationOnObject { op: Operation::ToInteger, typ: ObjectType::String }
+                    let parsed = str::parse::<u64>(value).map_err(|_| AmlError::InvalidOperationOnObject {
+                        op: Operation::ToInteger,
+                        typ: ObjectType::String,
                     })?;
                     Object::Integer(parsed)
                 }
@@ -1694,7 +1695,7 @@ where
             Object::String(ref value) => Object::String(value.clone()),
             Object::Integer(value) => match op.op {
                 Opcode::ToDecimalString => Object::String(value.to_string()),
-                Opcode::ToHexString => Object::String(alloc::format!("{:#x}", value)),
+                Opcode::ToHexString => Object::String(alloc::format!("{value:#x}")),
                 _ => panic!(),
             },
             Object::Buffer(ref bytes) => {
@@ -1704,8 +1705,8 @@ where
                     let mut string = String::new();
                     for byte in bytes {
                         let as_str = match op.op {
-                            Opcode::ToDecimalString => alloc::format!("{},", byte),
-                            Opcode::ToHexString => alloc::format!("{:#04X},", byte),
+                            Opcode::ToDecimalString => alloc::format!("{byte},"),
+                            Opcode::ToHexString => alloc::format!("{byte:#04X},"),
                             _ => panic!(),
                         };
                         string.push_str(&as_str);
@@ -1773,15 +1774,15 @@ where
         fn resolve_as_string(obj: &Object) -> String {
             match obj {
                 Object::Uninitialized => "[Uninitialized Object]".to_string(),
-                Object::Buffer(bytes) => String::from_utf8_lossy(&bytes).into_owned(),
+                Object::Buffer(bytes) => String::from_utf8_lossy(bytes).into_owned(),
                 Object::BufferField { .. } => "[Buffer Field]".to_string(),
                 Object::Device => "[Device]".to_string(),
                 Object::Event => "[Event]".to_string(),
                 Object::FieldUnit(_) => "[Field]".to_string(),
                 Object::Integer(value) => value.to_string(),
                 Object::Method { .. } | Object::NativeMethod { .. } => "[Control Method]".to_string(),
                 Object::Mutex { .. } => "[Mutex]".to_string(),
-                Object::Reference { inner, .. } => resolve_as_string(&*(inner.clone().unwrap_reference())),
+                Object::Reference { inner, .. } => resolve_as_string(&(inner.clone().unwrap_reference())),
                 Object::OpRegion(_) => "[Operation Region]".to_string(),
                 Object::Package(_) => "[Package]".to_string(),
                 Object::PowerResource { .. } => "[Power Resource]".to_string(),
@@ -1813,7 +1814,7 @@ where
                 buffer.extend(source2.to_buffer(if self.dsdt_revision >= 2 { 8 } else { 4 })?);
                 Object::Buffer(buffer).wrap()
             }
-            ObjectType::String | _ => {
+            _ => {
                 let source1 = resolve_as_string(&source1);
                 let source2 = resolve_as_string(&source2);
                 Object::String(source1 + &source2).wrap()
@@ -1944,14 +1945,14 @@ where
         let to_return = object.clone();
 
         match target {
-            Argument::Object(target) => match unsafe { target.gain_mut(&*token) } {
-                Object::Integer(target) => match unsafe { object.gain_mut(&*token) } {
+            Argument::Object(target) => match unsafe { target.gain_mut(&token) } {
+                Object::Integer(target) => match unsafe { object.gain_mut(&token) } {
                     Object::Integer(value) => {
                         *target = *value;
                     }
                     Object::BufferField { .. } => {
                         let mut buffer = [0u8; 8];
-                        unsafe { object.gain_mut(&*token) }.read_buffer_field(&mut buffer)?;
+                        unsafe { object.gain_mut(&token) }.read_buffer_field(&mut buffer)?;
                         let value = u64::from_le_bytes(buffer);
                         *target = value;
                     }
@@ -1964,12 +1965,12 @@ where
                         *target = as_integer;
                     }
                 },
-                Object::BufferField { .. } => match unsafe { object.gain_mut(&*token) } {
+                Object::BufferField { .. } => match unsafe { object.gain_mut(&token) } {
                     Object::Integer(value) => {
-                        unsafe { target.gain_mut(&*token) }.write_buffer_field(&value.to_le_bytes(), &*token)?;
+                        unsafe { target.gain_mut(&token) }.write_buffer_field(&value.to_le_bytes(), &token)?;
                     }
                     Object::Buffer(value) => {
-                        unsafe { target.gain_mut(&*token) }.write_buffer_field(&value.as_slice(), &*token)?;
+                        unsafe { target.gain_mut(&token) }.write_buffer_field(value.as_slice(), &token)?;
                     }
                     _ => panic!(),
                 },
@@ -1982,20 +1983,20 @@ where
                                 // TODO: this should store into the reference, potentially doing an
                                 // implicit cast
                                 unsafe {
-                                    *inner_inner.gain_mut(&*token) = object.gain_mut(&*token).clone();
+                                    *inner_inner.gain_mut(&token) = object.gain_mut(&token).clone();
                                 }
                             } else {
                                 // Overwrite the value
                                 unsafe {
-                                    *inner.gain_mut(&*token) = object.gain_mut(&*token).clone();
+                                    *inner.gain_mut(&token) = object.gain_mut(&token).clone();
                                 }
                             }
                         }
                         ReferenceKind::Unresolved => todo!(),
                     }
                 }
                 Object::Debug => {
-                    self.handler.handle_debug(&*object);
+                    self.handler.handle_debug(&object);
                 }
                 _ => panic!("Stores to objects like {:?} are not yet supported", target),
             },
@@ -2090,7 +2091,7 @@ where
 
         let value_bytes = match &*value {
             Object::Integer(value) => &value.to_le_bytes() as &[u8],
-            Object::Buffer(bytes) => &bytes,
+            Object::Buffer(bytes) => bytes,
             _ => Err(AmlError::ObjectNotOfExpectedType { expected: ObjectType::Integer, got: value.typ() })?,
         };
         let access_width_bits = field.flags.access_type_bytes()? * 8;
@@ -2173,7 +2174,7 @@ where
                     1 => self.handler.read_u8(address) as u64,
                     2 => self.handler.read_u16(address) as u64,
                     4 => self.handler.read_u32(address) as u64,
-                    8 => self.handler.read_u64(address) as u64,
+                    8 => self.handler.read_u64(address),
                     _ => panic!(),
                 }
             }),
@@ -2230,7 +2231,7 @@ where
         );
 
         match region.space {
-            RegionSpace::SystemMemory => Ok({
+            RegionSpace::SystemMemory => {
                 let address = region.base as usize + offset;
                 match length {
                     1 => self.handler.write_u8(address, value as u8),
@@ -2239,16 +2240,18 @@ where
                     8 => self.handler.write_u64(address, value),
                     _ => panic!(),
                 }
-            }),
-            RegionSpace::SystemIO => Ok({
+                Ok(())
+            }
+            RegionSpace::SystemIO => {
                 let address = region.base as u16 + offset as u16;
                 match length {
                     1 => self.handler.write_io_u8(address, value as u8),
                     2 => self.handler.write_io_u16(address, value as u16),
                     4 => self.handler.write_io_u32(address, value as u32),
                     _ => panic!(),
                 }
-            }),
+                Ok(())
+            }
             RegionSpace::PciConfig => {
                 let address = self.pci_address_for_device(&region.parent_device_path)?;
                 match length {
@@ -2434,10 +2437,10 @@ impl MethodContext {
     }
 
     fn contribute_arg(&mut self, arg: Argument) {
-        if let Some(in_flight) = self.in_flight.last_mut() {
-            if in_flight.arguments.len() < in_flight.expected_arguments {
-                in_flight.arguments.push(arg);
-            }
+        if let Some(in_flight) = self.in_flight.last_mut()
+            && in_flight.arguments.len() < in_flight.expected_arguments
+        {
+            in_flight.arguments.push(arg);
         }
     }
 

src/aml/namespace.rs

@@ -10,7 +10,10 @@ use alloc::{
     vec::Vec,
 };
 use bit_field::BitField;
-use core::{fmt, str, str::FromStr};
+use core::{
+    fmt,
+    str::{self, FromStr},
+};
 use log::{trace, warn};
 
 #[derive(Clone)]
@@ -257,10 +260,10 @@ impl Namespace {
 
             loop {
                 let name = level_name.resolve(&scope)?;
-                if let Ok((level, last_seg)) = self.get_level_for_path(&name) {
-                    if level.children.contains_key(&last_seg) {
-                        return Ok(name);
-                    }
+                if let Ok((level, last_seg)) = self.get_level_for_path(&name)
+                    && level.children.contains_key(&last_seg)
+                {
+                    return Ok(name);
                 }
 
                 // If we don't find it, move the scope up a level and search for it there recursively
@@ -296,7 +299,7 @@ impl Namespace {
                 panic!();
             };
             current_level =
-                current_level.children.get(&segment).ok_or(AmlError::LevelDoesNotExist(traversed_path.clone()))?;
+                current_level.children.get(segment).ok_or(AmlError::LevelDoesNotExist(traversed_path.clone()))?;
         }
 
         Ok((current_level, *last_seg))
@@ -326,7 +329,7 @@ impl Namespace {
             };
             current_level = current_level
                 .children
-                .get_mut(&segment)
+                .get_mut(segment)
                 .ok_or(AmlError::LevelDoesNotExist(traversed_path.clone()))?;
         }
 
@@ -369,12 +372,7 @@ impl fmt::Display for Namespace {
         const BRANCH: &str = "├── ";
         const END: &str = "└── ";
 
-        fn print_level(
-            namespace: &Namespace,
-            f: &mut fmt::Formatter<'_>,
-            level: &NamespaceLevel,
-            indent_stack: String,
-        ) -> fmt::Result {
+        fn print_level(f: &mut fmt::Formatter<'_>, level: &NamespaceLevel, indent_stack: String) -> fmt::Result {
             for (i, (name, (flags, object))) in level.values.iter().enumerate() {
                 let end = (i == level.values.len() - 1)
                     && level.children.iter().filter(|(_, l)| l.kind == NamespaceLevelKind::Scope).count() == 0;
@@ -389,9 +387,8 @@ impl fmt::Display for Namespace {
                 )?;
 
                 // If the object has a corresponding scope, print it here
-                if let Some(child_level) = level.children.get(&name) {
+                if let Some(child_level) = level.children.get(name) {
                     print_level(
-                        namespace,
                         f,
                         child_level,
                         if end { indent_stack.clone() + "    " } else { indent_stack.clone() + STEM },
@@ -404,14 +401,14 @@ impl fmt::Display for Namespace {
             for (i, (name, sub_level)) in remaining_scopes.iter().enumerate() {
                 let end = i == remaining_scopes.len() - 1;
                 writeln!(f, "{}{}{}:", &indent_stack, if end { END } else { BRANCH }, name.as_str())?;
-                print_level(namespace, f, sub_level, indent_stack.clone() + STEM)?;
+                print_level(f, sub_level, indent_stack.clone() + STEM)?;
             }
 
             Ok(())
         }
 
         writeln!(f, "\n    \\:")?;
-        print_level(self, f, &self.root, String::from("    "))
+        print_level(f, &self.root, String::from("    "))
     }
 }
 
@@ -615,15 +612,40 @@ impl fmt::Display for AmlName {
 pub struct NameSeg(pub(crate) [u8; 4]);
 
 impl NameSeg {
-    pub fn from_str(string: &str) -> Result<NameSeg, AmlError> {
+    pub fn from_bytes(bytes: [u8; 4]) -> Result<NameSeg, AmlError> {
+        if !is_lead_name_char(bytes[0]) {
+            return Err(AmlError::InvalidNameSeg(bytes));
+        }
+        if !is_name_char(bytes[1]) {
+            return Err(AmlError::InvalidNameSeg(bytes));
+        }
+        if !is_name_char(bytes[2]) {
+            return Err(AmlError::InvalidNameSeg(bytes));
+        }
+        if !is_name_char(bytes[3]) {
+            return Err(AmlError::InvalidNameSeg(bytes));
+        }
+        Ok(NameSeg(bytes))
+    }
+
+    pub fn as_str(&self) -> &str {
+        // We should only construct valid ASCII name segments
+        unsafe { str::from_utf8_unchecked(&self.0) }
+    }
+}
+
+impl FromStr for NameSeg {
+    type Err = AmlError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         // Each NameSeg can only have four chars, and must have at least one
-        if string.is_empty() || string.len() > 4 {
+        if s.is_empty() || s.len() > 4 {
             return Err(AmlError::InvalidNameSeg([0xff, 0xff, 0xff, 0xff]));
         }
 
         // We pre-fill the array with '_', so it will already be correct if the length is < 4
         let mut seg = [b'_'; 4];
-        let bytes = string.as_bytes();
+        let bytes = s.as_bytes();
 
         // Manually do the first one, because we have to check it's a LeadNameChar
         if !is_lead_name_char(bytes[0]) {
@@ -641,27 +663,6 @@ impl NameSeg {
 
         Ok(NameSeg(seg))
     }
-
-    pub fn from_bytes(bytes: [u8; 4]) -> Result<NameSeg, AmlError> {
-        if !is_lead_name_char(bytes[0]) {
-            return Err(AmlError::InvalidNameSeg(bytes));
-        }
-        if !is_name_char(bytes[1]) {
-            return Err(AmlError::InvalidNameSeg(bytes));
-        }
-        if !is_name_char(bytes[2]) {
-            return Err(AmlError::InvalidNameSeg(bytes));
-        }
-        if !is_name_char(bytes[3]) {
-            return Err(AmlError::InvalidNameSeg(bytes));
-        }
-        Ok(NameSeg(bytes))
-    }
-
-    pub fn as_str(&self) -> &str {
-        // We should only construct valid ASCII name segments
-        unsafe { str::from_utf8_unchecked(&self.0) }
-    }
 }
 
 pub fn is_lead_name_char(c: u8) -> bool {