chore: fix, Rust, lint/fmt, issues

Batch Justfile audit: standardised naming (lowercase→Justfile),
fixed parse errors, removed useless build-riscv from non-Rust repos,
added missing assail recipe, and fixed code quality issues.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

src/abi/mod.rs

@@ -47,7 +47,12 @@ impl Clock {
 
 impl fmt::Display for Clock {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}ms ({:.1}Hz)", self.base_period_ms, self.frequency_hz())
+        write!(
+            f,
+            "{}ms ({:.1}Hz)",
+            self.base_period_ms,
+            self.frequency_hz()
+        )
     }
 }
 
@@ -152,7 +157,10 @@ impl std::str::FromStr for SignalType {
             "int" | "int32" | "integer" => Ok(Self::Int),
             "float" | "f32" => Ok(Self::Float),
             "real" | "double" | "f64" => Ok(Self::Real),
-            other => Err(format!("Unknown signal type: '{}'. Expected bool, int, float, or real.", other)),
+            other => Err(format!(
+                "Unknown signal type: '{}'. Expected bool, int, float, or real.",
+                other
+            )),
         }
     }
 }
@@ -261,23 +269,37 @@ impl LustreNode {
             errors.push("Node name must not be empty".to_string());
         }
 
-        if !self.name.chars().next().map_or(false, |c| c.is_ascii_alphabetic() || c == '_') {
-            errors.push(format!("Node name '{}' must start with a letter or underscore", self.name));
+        if !self
+            .name
+            .chars()
+            .next()
+            .is_some_and(|c| c.is_ascii_alphabetic() || c == '_')
+        {
+            errors.push(format!(
+                "Node name '{}' must start with a letter or underscore",
+                self.name
+            ));
         }
 
         if self.inputs.is_empty() {
             errors.push(format!("Node '{}' must have at least one input", self.name));
         }
 
         if self.outputs.is_empty() {
-            errors.push(format!("Node '{}' must have at least one output", self.name));
+            errors.push(format!(
+                "Node '{}' must have at least one output",
+                self.name
+            ));
         }
 
         // Check for duplicate signal names across inputs and outputs.
         let mut seen = std::collections::HashSet::new();
         for sig in self.inputs.iter().chain(self.outputs.iter()) {
             if !seen.insert(&sig.name) {
-                errors.push(format!("Duplicate signal name '{}' in node '{}'", sig.name, self.name));
+                errors.push(format!(
+                    "Duplicate signal name '{}' in node '{}'",
+                    sig.name, self.name
+                ));
             }
         }
 
@@ -406,7 +428,12 @@ impl EmbeddedTarget {
     /// Return recommended compiler optimisation flags for this target.
     pub fn compiler_flags(&self) -> &'static [&'static str] {
         match self {
-            Self::ArmCortexM => &["-mcpu=cortex-m4", "-mthumb", "-mfloat-abi=hard", "-mfpu=fpv4-sp-d16"],
+            Self::ArmCortexM => &[
+                "-mcpu=cortex-m4",
+                "-mthumb",
+                "-mfloat-abi=hard",
+                "-mfpu=fpv4-sp-d16",
+            ],
             Self::RiscV => &["-march=rv32imac", "-mabi=ilp32"],
             Self::X86 => &["-march=native", "-O2"],
         }
@@ -456,7 +483,12 @@ pub struct Wcet {
 
 impl Wcet {
     /// Create a new WCET result.
-    pub fn new(node_name: impl Into<String>, estimated_us: u64, deadline_us: u64, analysis_performed: bool) -> Self {
+    pub fn new(
+        node_name: impl Into<String>,
+        estimated_us: u64,
+        deadline_us: u64,
+        analysis_performed: bool,
+    ) -> Self {
         Self {
             node_name: node_name.into(),
             estimated_us,
@@ -496,7 +528,11 @@ impl Wcet {
 
 impl fmt::Display for Wcet {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let status = if self.meets_deadline() { "OK" } else { "VIOLATION" };
+        let status = if self.meets_deadline() {
+            "OK"
+        } else {
+            "VIOLATION"
+        };
         write!(
             f,
             "WCET({}) = {}us / {}us deadline [{}] (utilisation: {:.1}%)",
@@ -561,16 +597,34 @@ mod tests {
 
     #[test]
     fn test_safety_standard_parsing() {
-        assert_eq!("DO-178C".parse::<SafetyStandard>().unwrap(), SafetyStandard::Do178c);
-        assert_eq!("IEC-61508".parse::<SafetyStandard>().unwrap(), SafetyStandard::Iec61508);
-        assert_eq!("ISO-26262".parse::<SafetyStandard>().unwrap(), SafetyStandard::Iso26262);
+        assert_eq!(
+            "DO-178C".parse::<SafetyStandard>().unwrap(),
+            SafetyStandard::Do178c
+        );
+        assert_eq!(
+            "IEC-61508".parse::<SafetyStandard>().unwrap(),
+            SafetyStandard::Iec61508
+        );
+        assert_eq!(
+            "ISO-26262".parse::<SafetyStandard>().unwrap(),
+            SafetyStandard::Iso26262
+        );
     }
 
     #[test]
     fn test_embedded_target_parsing() {
-        assert_eq!("arm-cortex-m".parse::<EmbeddedTarget>().unwrap(), EmbeddedTarget::ArmCortexM);
-        assert_eq!("riscv".parse::<EmbeddedTarget>().unwrap(), EmbeddedTarget::RiscV);
-        assert_eq!("x86".parse::<EmbeddedTarget>().unwrap(), EmbeddedTarget::X86);
+        assert_eq!(
+            "arm-cortex-m".parse::<EmbeddedTarget>().unwrap(),
+            EmbeddedTarget::ArmCortexM
+        );
+        assert_eq!(
+            "riscv".parse::<EmbeddedTarget>().unwrap(),
+            EmbeddedTarget::RiscV
+        );
+        assert_eq!(
+            "x86".parse::<EmbeddedTarget>().unwrap(),
+            EmbeddedTarget::X86
+        );
     }
 
     #[test]
@@ -589,9 +643,9 @@ mod tests {
     fn test_wcet_safety_standard_compliance() {
         // 70% utilisation => 30% margin => passes all standards
         let w = Wcet::new("ctrl", 700, 1000, true);
-        assert!(w.satisfies_standard(&SafetyStandard::Iso26262));  // needs 20%
-        assert!(w.satisfies_standard(&SafetyStandard::Iec61508));  // needs 15%
-        assert!(w.satisfies_standard(&SafetyStandard::Do178c));    // needs 10%
+        assert!(w.satisfies_standard(&SafetyStandard::Iso26262)); // needs 20%
+        assert!(w.satisfies_standard(&SafetyStandard::Iec61508)); // needs 15%
+        assert!(w.satisfies_standard(&SafetyStandard::Do178c)); // needs 10%
 
         // 95% utilisation => 5% margin => fails all
         let w_tight = Wcet::new("ctrl", 950, 1000, true);
@@ -604,15 +658,30 @@ mod tests {
     fn test_temporal_operator_display() {
         assert_eq!(format!("{}", TemporalOperator::Pre), "pre");
         assert_eq!(
-            format!("{}", TemporalOperator::Fby { init_expr: "0".to_string() }),
+            format!(
+                "{}",
+                TemporalOperator::Fby {
+                    init_expr: "0".to_string()
+                }
+            ),
             "0 fby"
         );
         assert_eq!(
-            format!("{}", TemporalOperator::When { clock_signal: "clk_10hz".to_string() }),
+            format!(
+                "{}",
+                TemporalOperator::When {
+                    clock_signal: "clk_10hz".to_string()
+                }
+            ),
             "when clk_10hz"
         );
         assert_eq!(
-            format!("{}", TemporalOperator::Merge { clock_signal: "sel".to_string() }),
+            format!(
+                "{}",
+                TemporalOperator::Merge {
+                    clock_signal: "sel".to_string()
+                }
+            ),
             "merge(sel)"
         );
     }

src/codegen/c_gen.rs

@@ -70,7 +70,7 @@ fn generate_header(node: &ParsedNode, manifest: &Manifest) -> String {
         node.clock.base_period_ms,
         node.clock.frequency_hz(),
     ));
-    buf.push_str(&format!("typedef struct {{\n"));
+    buf.push_str("typedef struct {\n");
 
     // One state field per output (for fby previous value).
     for output in &node.outputs {
@@ -84,7 +84,9 @@ fn generate_header(node: &ParsedNode, manifest: &Manifest) -> String {
 
     // Tick counter for multi-rate scheduling.
     if node.is_multi_rate {
-        buf.push_str("    uint32_t tick_count;  /**< Base-clock tick counter for rate division */\n");
+        buf.push_str(
+            "    uint32_t tick_count;  /**< Base-clock tick counter for rate division */\n",
+        );
     }
 
     // Initialisation flag.
@@ -93,8 +95,11 @@ fn generate_header(node: &ParsedNode, manifest: &Manifest) -> String {
     buf.push_str(&format!("}} {}_state_t;\n\n", node.name));
 
     // Input struct.
-    buf.push_str(&format!("/**\n * Input signals for node '{}'.\n */\n", node.name));
-    buf.push_str(&format!("typedef struct {{\n"));
+    buf.push_str(&format!(
+        "/**\n * Input signals for node '{}'.\n */\n",
+        node.name
+    ));
+    buf.push_str("typedef struct {\n");
     for input in &node.inputs {
         buf.push_str(&format!(
             "    {} {};  /**< Input signal '{}' (rate: /{}) */\n",
@@ -107,8 +112,11 @@ fn generate_header(node: &ParsedNode, manifest: &Manifest) -> String {
     buf.push_str(&format!("}} {}_input_t;\n\n", node.name));
 
     // Output struct.
-    buf.push_str(&format!("/**\n * Output signals for node '{}'.\n */\n", node.name));
-    buf.push_str(&format!("typedef struct {{\n"));
+    buf.push_str(&format!(
+        "/**\n * Output signals for node '{}'.\n */\n",
+        node.name
+    ));
+    buf.push_str("typedef struct {\n");
     for output in &node.outputs {
         buf.push_str(&format!(
             "    {} {};  /**< Output signal '{}' */\n",

src/codegen/lustre_gen.rs

@@ -196,10 +196,7 @@ fn generate_equations(node: &ParsedNode) -> Vec<String> {
                     ));
                 }
             } else {
-                equations.push(format!(
-                    "{} = {}_prev",
-                    output.name, output.name,
-                ));
+                equations.push(format!("{} = {}_prev", output.name, output.name,));
             }
         }
     } else {
@@ -284,7 +281,10 @@ mod tests {
     #[test]
     fn test_lustre_fby_present() {
         let lus = generate_lustre_node(&simple_node());
-        assert!(lus.contains("fby"), "Expected fby operator in generated Lustre");
+        assert!(
+            lus.contains("fby"),
+            "Expected fby operator in generated Lustre"
+        );
     }
 
     #[test]
@@ -306,9 +306,18 @@ mod tests {
             is_multi_rate: true,
         };
         let lus = generate_lustre_node(&node);
-        assert!(lus.contains("when"), "Expected 'when' operator for multi-rate");
-        assert!(lus.contains("merge"), "Expected 'merge' operator for multi-rate");
-        assert!(lus.contains("slow_sampled"), "Expected sampled local for sub-rate input");
+        assert!(
+            lus.contains("when"),
+            "Expected 'when' operator for multi-rate"
+        );
+        assert!(
+            lus.contains("merge"),
+            "Expected 'merge' operator for multi-rate"
+        );
+        assert!(
+            lus.contains("slow_sampled"),
+            "Expected sampled local for sub-rate input"
+        );
     }
 
     #[test]
@@ -335,6 +344,9 @@ mod tests {
             is_multi_rate: false,
         };
         let lus = generate_lustre_node(&node);
-        assert!(lus.contains("false fby"), "Expected 'false fby' for bool init");
+        assert!(
+            lus.contains("false fby"),
+            "Expected 'false fby' for bool init"
+        );
     }
 }

src/codegen/mod.rs

@@ -33,8 +33,7 @@ pub fn generate_all(manifest: &Manifest, output_dir: &str) -> Result<()> {
     fs::create_dir_all(out).context("Failed to create output directory")?;
 
     // Stage 1: Parse and validate node definitions from the manifest.
-    let parsed_nodes = parser::parse_nodes(manifest)
-        .context("Failed to parse node definitions")?;
+    let parsed_nodes = parser::parse_nodes(manifest).context("Failed to parse node definitions")?;
 
     // Stage 2: Generate Lustre (.lus) files.
     for node in &parsed_nodes {
@@ -69,10 +68,7 @@ pub fn generate_all(manifest: &Manifest, output_dir: &str) -> Result<()> {
 /// Generate a WCET analysis report for all nodes.
 /// This is a static estimation based on node complexity; a real tool chain
 /// would integrate with aiT, Bound-T, or OTAWA for precise analysis.
-fn generate_wcet_report(
-    nodes: &[parser::ParsedNode],
-    manifest: &Manifest,
-) -> String {
+fn generate_wcet_report(nodes: &[parser::ParsedNode], manifest: &Manifest) -> String {
     use crate::abi::{SafetyStandard, Wcet};
 
     let standard: SafetyStandard = manifest
@@ -91,10 +87,7 @@ fn generate_wcet_report(
         "Target: {} ({})\n",
         manifest.target.platform, manifest.target.safety_standard
     ));
-    report.push_str(&format!(
-        "Deadline: {}us\n\n",
-        manifest.timing.deadline_us
-    ));
+    report.push_str(&format!("Deadline: {}us\n\n", manifest.timing.deadline_us));
 
     let mut all_pass = true;
     for node in nodes {
@@ -108,12 +101,7 @@ fn generate_wcet_report(
             + (node.outputs.len() as u64 * 15)
             + (node.operator_count as u64 * 20);
 
-        let wcet = Wcet::new(
-            &node.name,
-            estimated_us,
-            manifest.timing.deadline_us,
-            true,
-        );
+        let wcet = Wcet::new(&node.name, estimated_us, manifest.timing.deadline_us, true);
 
         let compliant = wcet.satisfies_standard(&standard);
         if !compliant {
@@ -124,7 +112,11 @@ fn generate_wcet_report(
         report.push_str(&format!(
             "  {} compliant: {}\n\n",
             standard.display_name(),
-            if compliant { "YES" } else { "NO — margin insufficient" }
+            if compliant {
+                "YES"
+            } else {
+                "NO — margin insufficient"
+            }
         ));
     }
 

src/codegen/parser.rs

@@ -51,8 +51,7 @@ pub fn parse_nodes(manifest: &Manifest) -> Result<Vec<ParsedNode>> {
     let mut parsed = Vec::with_capacity(manifest.nodes.len());
     for (i, node_cfg) in manifest.nodes.iter().enumerate() {
         let ctx = format!("nodes[{}] ('{}')", i, node_cfg.name);
-        let pn = parse_single_node(node_cfg)
-            .with_context(|| format!("Failed to parse {}", ctx))?;
+        let pn = parse_single_node(node_cfg).with_context(|| format!("Failed to parse {}", ctx))?;
         parsed.push(pn);
     }
     Ok(parsed)
@@ -162,10 +161,7 @@ mod tests {
 
     #[test]
     fn test_parse_multi_rate_node() {
-        let m = minimal_manifest(
-            vec!["fast:real", "slow:real@10"],
-            vec!["out:real"],
-        );
+        let m = minimal_manifest(vec!["fast:real", "slow:real@10"], vec!["out:real"]);
         let nodes = parse_nodes(&m).unwrap();
         assert!(nodes[0].is_multi_rate);
         assert_eq!(nodes[0].inputs[1].rate, 10);