update linting, address lints

.github/workflows/test.yml

@@ -19,12 +19,11 @@ jobs:
  - uses: actions/checkout@master
  - uses: dtolnay/rust-toolchain@master
  with:
- toolchain: nightly-2022-11-30
+ toolchain: nightly-2023-10-21
  components: clippy
- - uses: actions-rs/clippy-check@v1
+ - uses: actions-rs-plus/clippy-check@v2
  with:
- token: ${{ secrets.GITHUB_TOKEN }}
- args: --all --all-targets
+ args: --all --all-targets --features format-generated-code
 
  internal-tests:
  runs-on: ubuntu-latest

build/binder.rs

@@ -11,6 +11,7 @@ pub fn generate<W: Write>(modules: Vec<String>, out: &mut W) {
  #[allow(clippy::field_reassign_with_default)]
  #[allow(non_snake_case)]
  #[allow(clippy::unnecessary_cast)]
+ #[allow(clippy::bad_bit_mask)]
  #[cfg(feature = #module)]
  pub mod #module_ident;
  }

build/parser.rs

@@ -57,17 +57,14 @@ impl MavProfile {
  fn update_enums(mut self) -> Self {
  for msg in self.messages.values() {
  for field in &msg.fields {
- if let Some(ref enum_name) = field.enumtype {
- // it is an enum
- if let Some(ref dsp) = field.display {
- // it is a bitmask
- if dsp == "bitmask" {
- // find the corresponding enum
- for enm in self.enums.values_mut() {
- if enm.name == *enum_name {
- // this is the right enum
- enm.bitfield = Some(field.mavtype.rust_primitive_type());
- }
+ if let Some(enum_name) = &field.enumtype {
+ // it is a bitmask
+ if let Some("bitmask") = &field.display.as_deref() {
+ // find the corresponding enum
+ for enm in self.enums.values_mut() {
+ if enm.name == *enum_name {
+ // this is the right enum
+ enm.bitfield = Some(field.mavtype.rust_primitive_type());
  }
  }
  }
@@ -503,13 +500,13 @@ impl MavMessage {
  fn emit_serialize_vars(&self) -> TokenStream {
  let ser_vars = self.fields.iter().map(|f| f.rust_writer());
  quote! {
- let mut _tmp = BytesMut::new(bytes);
+ let mut __tmp = BytesMut::new(bytes);
  #(#ser_vars)*
  if matches!(version, MavlinkVersion::V2) {
- let len = _tmp.len();
- crate::remove_trailing_zeroes(&mut bytes[..len])
+ let len = __tmp.len();
+ crate::remove_trailing_zeroes(&bytes[..len])
  } else {
- _tmp.len()
+ __tmp.len()
  }
  }
  }
@@ -528,21 +525,21 @@ impl MavMessage {
  }
  } else {
  quote! {
- let avail_len = _input.len();
+ let avail_len = __input.len();
 
  let mut payload_buf = [0; Self::ENCODED_LEN];
  let mut buf = if avail_len < Self::ENCODED_LEN {
  //copy available bytes into an oversized buffer filled with zeros
- payload_buf[0..avail_len].copy_from_slice(_input);
+ payload_buf[0..avail_len].copy_from_slice(__input);
  Bytes::new(&payload_buf)
  } else {
  // fast zero copy
- Bytes::new(_input)
+ Bytes::new(__input)
  };
 
- let mut _struct = Self::default();
+ let mut __struct = Self::default();
  #(#deser_vars)*
- Ok(_struct)
+ Ok(__struct)
  }
  }
  }
@@ -607,7 +604,7 @@ impl MavMessage {
  const EXTRA_CRC: u8 = #extra_crc;
  const ENCODED_LEN: usize = #msg_encoded_len;
 
- fn deser(_version: MavlinkVersion, _input: &[u8]) -> Result<Self, ParserError> {
+ fn deser(_version: MavlinkVersion, __input: &[u8]) -> Result<Self, ParserError> {
  #deser_vars
  }
 
@@ -643,7 +640,7 @@ impl MavField {
  if matches!(self.mavtype, MavType::Array(_, _)) {
  let rt = TokenStream::from_str(&self.mavtype.rust_type()).unwrap();
  mavtype = quote!(#rt);
- } else if let Some(ref enumname) = self.enumtype {
+ } else if let Some(enumname) = &self.enumtype {
  let en = TokenStream::from_str(enumname).unwrap();
  mavtype = quote!(#en);
  } else {
@@ -695,15 +692,15 @@ impl MavField {
  }
  let ts = TokenStream::from_str(&name).unwrap();
  let name = quote!(#ts);
- let buf = format_ident!("_tmp");
+ let buf = format_ident!("__tmp");
  self.mavtype.rust_writer(&name, buf)
  }
 
  /// Emit reader
  fn rust_reader(&self) -> TokenStream {
  let _name = TokenStream::from_str(&self.name).unwrap();
 
- let name = quote!(_struct.#_name);
+ let name = quote!(__struct.#_name);
  let buf = format_ident!("buf");
  if let Some(enum_name) = &self.enumtype {
  // TODO: handle enum arrays properly, rather than just generating
@@ -1122,7 +1119,7 @@ pub fn parse_profile(
  let attr = attr.unwrap();
  match stack.last() {
  Some(&MavXmlElement::Enum) => {
- if let b"name" = attr.key.into_inner() {
+ if attr.key.into_inner() == b"name" {
  mavenum.name = attr
  .value
  .clone()
@@ -1273,7 +1270,7 @@ pub fn parse_profile(
  entry.description = Some(s.replace('\n', " "));
  }
  (Some(&Param), Some(&Entry)) => {
- if let Some(ref mut params) = entry.params {
+ if let Some(params) = &mut entry.params {
  // Some messages can jump between values, like:
  // 0, 1, 2, 7
  if params.len() < paramid.unwrap() {
@@ -1382,21 +1379,21 @@ pub fn extra_crc(msg: &MavMessage) -> u8 {
  let mut crc = CRCu16::crc16mcrf4cc();
 
  crc.digest(msg.name.as_bytes());
- crc.digest(" ".as_bytes());
+ crc.digest(b" ");
 
  let mut f = msg.fields.clone();
  // only mavlink 1 fields should be part of the extra_crc
  f.retain(|f| !f.is_extension);
  f.sort_by(|a, b| a.mavtype.compare(&b.mavtype));
  for field in &f {
  crc.digest(field.mavtype.primitive_type().as_bytes());
- crc.digest(" ".as_bytes());
+ crc.digest(b" ");
  if field.name == "mavtype" {
- crc.digest("type".as_bytes());
+ crc.digest(b"type");
  } else {
  crc.digest(field.name.as_bytes());
  }
- crc.digest(" ".as_bytes());
+ crc.digest(b" ");
  if let MavType::Array(_, size) = field.mavtype {
  crc.digest(&[size as u8]);
  }
@@ -1443,31 +1440,25 @@ impl MavXmlFilter {
  Ok(content) => {
  match content {
  Event::Start(bytes) | Event::Empty(bytes) => {
- let id = match identify_element(bytes.name().into_inner()) {
- None => {
- panic!(
- "unexpected element {:?}",
- String::from_utf8_lossy(bytes.name().into_inner())
- );
- }
- Some(kind) => kind,
+ let Some(id) = identify_element(bytes.name().into_inner()) else {
+ panic!(
+ "unexpected element {:?}",
+ String::from_utf8_lossy(bytes.name().into_inner())
+ );
  };
- if let MavXmlElement::Extensions = id {
+ if id == MavXmlElement::Extensions {
  self.extension_filter.is_in = true;
  }
  }
  Event::End(bytes) => {
- let id = match identify_element(bytes.name().into_inner()) {
- None => {
- panic!(
- "unexpected element {:?}",
- String::from_utf8_lossy(bytes.name().into_inner())
- );
- }
- Some(kind) => kind,
+ let Some(id) = identify_element(bytes.name().into_inner()) else {
+ panic!(
+ "unexpected element {:?}",
+ String::from_utf8_lossy(bytes.name().into_inner())
+ );
  };
 
- if let MavXmlElement::Message = id {
+ if id == MavXmlElement::Message {
  self.extension_filter.is_in = false;
  }
  }

src/bin/mavlink-dump.rs

@@ -49,7 +49,7 @@ fn main() {
  println!("received: {msg:?}");
  }
  Err(MessageReadError::Io(e)) => {
- if let std::io::ErrorKind::WouldBlock = e.kind() {
+ if e.kind() == std::io::ErrorKind::WouldBlock {
  //no messages currently available to receive -- wait a while
  thread::sleep(Duration::from_secs(1));
  continue;

src/connection/udp.rs

@@ -74,8 +74,7 @@ struct PacketBuf {
 
 impl PacketBuf {
  pub fn new() -> Self {
- let mut v = Vec::new();
- v.resize(65536, 0);
+ let v = vec![0; 65536];
  Self {
  buf: v,
  start: 0,

src/embedded.rs

@@ -5,8 +5,8 @@ pub trait Read {
  fn read_u8(&mut self) -> Result<u8, MessageReadError>;
 
  fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), MessageReadError> {
- for i in 0..buf.len() {
- buf[i] = self.read_u8()?;
+ for byte in buf {
+ *byte = self.read_u8()?;
  }
 
  Ok(())
@@ -26,8 +26,8 @@ pub trait Write {
 
 impl<W: embedded_hal::serial::Write<u8>> Write for W {
  fn write_all(&mut self, buf: &[u8]) -> Result<(), MessageWriteError> {
- for i in 0..buf.len() {
- nb::block!(self.write(buf[i])).map_err(|_| MessageWriteError::Io)?;
+ for byte in buf {
+ nb::block!(self.write(*byte)).map_err(|_| MessageWriteError::Io)?;
  }
 
  Ok(())

src/lib.rs

@@ -191,7 +191,7 @@ impl<M: Message> MavFrame<M> {
 
  let msg_id = match version {
  MavlinkVersion::V2 => buf.get_u24_le(),
- MavlinkVersion::V1 => buf.get_u8() as u32,
+ MavlinkVersion::V1 => buf.get_u8().into(),
  };
 
  match M::parse(version, msg_id, buf.remaining_bytes()) {
@@ -498,10 +498,10 @@ impl MAVLinkV2MessageRaw {
  let payload_length: usize = self.payload_length().into();
 
  // Signature to ensure the link is tamper-proof.
- let signature_size = if (self.incompatibility_flags() & MAVLINK_IFLAG_SIGNED) != 0 {
- Self::SIGNATURE_SIZE
- } else {
+ let signature_size = if (self.incompatibility_flags() & MAVLINK_IFLAG_SIGNED) == 0 {
  0
+ } else {
+ Self::SIGNATURE_SIZE
  };
 
  &mut self.0
@@ -521,10 +521,10 @@ impl MAVLinkV2MessageRaw {
  pub fn raw_bytes(&self) -> &[u8] {
  let payload_length = self.payload_length() as usize;
 
- let signature_size = if (self.incompatibility_flags() & MAVLINK_IFLAG_SIGNED) != 0 {
- Self::SIGNATURE_SIZE
- } else {
+ let signature_size = if (self.incompatibility_flags() & MAVLINK_IFLAG_SIGNED) == 0 {
  0
+ } else {
+ Self::SIGNATURE_SIZE
  };
 
  &self.0[..(1 + Self::HEADER_SIZE + payload_length + signature_size + 2)]

src/utils.rs

@@ -4,7 +4,7 @@
 ///
 /// There must always be at least one remaining byte even if it is a
 /// zero byte.
-pub(crate) fn remove_trailing_zeroes(data: &mut [u8]) -> usize {
+pub(crate) fn remove_trailing_zeroes(data: &[u8]) -> usize {
  let mut len = data.len();
 
  for b in data[1..].iter().rev() {

tests/process_log_files.rs

@@ -36,7 +36,7 @@ mod process_files {
  counter += 1;
  }
  Err(MessageReadError::Io(e)) => {
- if let std::io::ErrorKind::WouldBlock = e.kind() {
+ if e.kind() == std::io::ErrorKind::WouldBlock {
  continue;
  } else {
  println!("recv error: {e:?}");