Merge pull request #68 from projectgus/tweaks/codegen_warnings

Remove warnings in generated code

Author: Pascal Hertleif

README.md

@@ -36,6 +36,7 @@ fn main() {
     let config = Config::builder()
         .dbc_name("example.dbc")
         .dbc_content(&dbc_file)
+        //.allow_dead_code(true) // Don't emit warnings if not all generated code is used
         //.impl_arbitrary(FeatureConfig::Gated("arbitrary")) // Optional impls.
         //.impl_debug(FeatureConfig::Always)                 // See rustdoc for more,
         //.check_ranges(FeatureConfig::Never)                // or look below for an example.

src/lib.rs

@@ -73,9 +73,13 @@ pub struct Config<'a> {
     #[builder(default)]
     pub impl_error: FeatureConfig<'a>,
 
-    /// Optional: Validate min and max values in generated signal setters. Default: `Always`.
+    /// Optional: Validate min and max values in generated signal setters. Default: `Always`
     #[builder(default = FeatureConfig::Always)]
     pub check_ranges: FeatureConfig<'a>,
+
+    /// Optional: Allow dead code in the generated module. Default: `false`.
+    #[builder(default)]
+    pub allow_dead_code: bool,
 }
 
 /// Configuration for including features in the codegenerator.
@@ -112,16 +116,19 @@ pub fn codegen(config: Config<'_>, out: impl Write) -> Result<()> {
     writeln!(&mut w, "// Generated code!")?;
     writeln!(
         &mut w,
-        "#![allow(unused_comparisons, unreachable_patterns)]"
+        "#![allow(unused_comparisons, unreachable_patterns, unused_imports)]"
     )?;
+    if config.allow_dead_code {
+        writeln!(&mut w, "#![allow(dead_code)]")?;
+    }
     writeln!(&mut w, "#![allow(clippy::let_and_return, clippy::eq_op)]")?;
     writeln!(
         &mut w,
         "#![allow(clippy::useless_conversion, clippy::unnecessary_cast)]"
     )?;
     writeln!(
         &mut w,
-        "#![allow(clippy::excessive_precision, clippy::manual_range_contains, clippy::absurd_extreme_comparisons)]"
+        "#![allow(clippy::excessive_precision, clippy::manual_range_contains, clippy::absurd_extreme_comparisons, clippy::too_many_arguments)]"
     )?;
     writeln!(&mut w, "#![deny(clippy::arithmetic_side_effects)]")?;
     writeln!(&mut w)?;
@@ -326,7 +333,8 @@ fn render_message(mut w: impl Write, config: &Config<'_>, msg: &Message, dbc: &D
             let mut w = PadAdapter::wrap(&mut w);
             writeln!(
                 &mut w,
-                "let mut res = Self {{ raw: [0u8; {}] }};",
+                "let {}res = Self {{ raw: [0u8; {}] }};",
+                if msg.signals().is_empty() { "" } else { "mut " },
                 msg.message_size()
             )?;
             for signal in msg.signals().iter() {
@@ -1347,21 +1355,22 @@ fn render_arbitrary(mut w: impl Write, config: &Config<'_>, msg: &Message) -> Re
         typ = type_name(msg.message_name())
     )?;
     {
+        let filtered_signals: Vec<&Signal> = msg
+            .signals()
+            .iter()
+            .filter(|signal| {
+                *signal.multiplexer_indicator() == MultiplexIndicator::Plain
+                    || *signal.multiplexer_indicator() == MultiplexIndicator::Multiplexor
+            })
+            .collect();
         let mut w = PadAdapter::wrap(&mut w);
         writeln!(
             w,
-            "fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self, arbitrary::Error> {{"
+            "fn arbitrary({}u: &mut Unstructured<'a>) -> Result<Self, arbitrary::Error> {{",
+            if filtered_signals.is_empty() { "_" } else { "" },
         )?;
         {
             let mut w = PadAdapter::wrap(&mut w);
-            let filtered_signals: Vec<&Signal> = msg
-                .signals()
-                .iter()
-                .filter(|signal| {
-                    *signal.multiplexer_indicator() == MultiplexIndicator::Plain
-                        || *signal.multiplexer_indicator() == MultiplexIndicator::Multiplexor
-                })
-                .collect();
 
             for signal in filtered_signals.iter() {
                 writeln!(

testing/can-messages/src/messages.rs

@@ -1,11 +1,12 @@
 // Generated code!
-#![allow(unused_comparisons, unreachable_patterns)]
+#![allow(unused_comparisons, unreachable_patterns, unused_imports)]
 #![allow(clippy::let_and_return, clippy::eq_op)]
 #![allow(clippy::useless_conversion, clippy::unnecessary_cast)]
 #![allow(
     clippy::excessive_precision,
     clippy::manual_range_contains,
-    clippy::absurd_extreme_comparisons
+    clippy::absurd_extreme_comparisons,
+    clippy::too_many_arguments
 )]
 #![deny(clippy::arithmetic_side_effects)]
 
@@ -35,6 +36,8 @@ pub enum Messages {
     MultiplexTest(MultiplexTest),
     /// IntegerFactorOffset
     IntegerFactorOffset(IntegerFactorOffset),
+    /// MsgWithoutSignals
+    MsgWithoutSignals(MsgWithoutSignals),
 }
 
 impl Messages {
@@ -49,6 +52,7 @@ impl Messages {
             1028 => Messages::Dolor(Dolor::try_from(payload)?),
             200 => Messages::MultiplexTest(MultiplexTest::try_from(payload)?),
             1337 => Messages::IntegerFactorOffset(IntegerFactorOffset::try_from(payload)?),
+            513 => Messages::MsgWithoutSignals(MsgWithoutSignals::try_from(payload)?),
             n => return Err(CanError::UnknownMessageId(n)),
         };
         Ok(res)
@@ -1822,6 +1826,62 @@ impl<'a> Arbitrary<'a> for IntegerFactorOffset {
     }
 }
 
+/// MsgWithoutSignals
+///
+/// - ID: 513 (0x201)
+/// - Size: 8 bytes
+/// - Transmitter: Ipsum
+#[derive(Clone, Copy)]
+pub struct MsgWithoutSignals {
+    raw: [u8; 8],
+}
+
+impl MsgWithoutSignals {
+    pub const MESSAGE_ID: u32 = 513;
+
+    /// Construct new MsgWithoutSignals from values
+    pub fn new() -> Result<Self, CanError> {
+        let res = Self { raw: [0u8; 8] };
+        Ok(res)
+    }
+
+    /// Access message payload raw value
+    pub fn raw(&self) -> &[u8; 8] {
+        &self.raw
+    }
+}
+
+impl core::convert::TryFrom<&[u8]> for MsgWithoutSignals {
+    type Error = CanError;
+
+    #[inline(always)]
+    fn try_from(payload: &[u8]) -> Result<Self, Self::Error> {
+        if payload.len() != 8 {
+            return Err(CanError::InvalidPayloadSize);
+        }
+        let mut raw = [0u8; 8];
+        raw.copy_from_slice(&payload[..8]);
+        Ok(Self { raw })
+    }
+}
+
+impl core::fmt::Debug for MsgWithoutSignals {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        if f.alternate() {
+            f.debug_struct("MsgWithoutSignals").finish()
+        } else {
+            f.debug_tuple("MsgWithoutSignals").field(&self.raw).finish()
+        }
+    }
+}
+
+#[cfg(feature = "arb")]
+impl<'a> Arbitrary<'a> for MsgWithoutSignals {
+    fn arbitrary(_u: &mut Unstructured<'a>) -> Result<Self, arbitrary::Error> {
+        MsgWithoutSignals::new().map_err(|_| arbitrary::Error::IncorrectFormat)
+    }
+}
+
 /// This is just to make testing easier
 #[allow(dead_code)]
 fn main() {}

testing/dbc-examples/example.dbc

@@ -47,6 +47,8 @@ BO_ 1337 IntegerFactorOffset: 8 Sit
  SG_ ByteWithNegativeOffset : 24|8@1+ (1,-1) [0|255] "" Vector__XXX
  SG_ ByteWithNegativeMin : 32|8@1+ (1,-1) [-127|127] "" Vector__XXX
 
+BO_ 513 MsgWithoutSignals: 8 Ipsum
+
 VAL_ 512 Three 0 "OFF" 1 "ON" 2 "ONER" 3 "ONEST";
 VAL_ 512 Four 0 "Off" 1 "On" 2 "Oner" 3 "Onest";
 VAL_ 512 Type 0 "0Off" 1 "1On";