fprime-fpp-python 3.3.24__tar.gz → 3.3.25__tar.gz

{fprime_fpp_python-3.3.24 → fprime_fpp_python-3.3.25}/Cargo.lock

@@ -352,7 +352,7 @@ dependencies = [
 
 [[package]]
 name = "fpp"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "fpp_analysis",
  "fpp_core",
@@ -363,7 +363,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_analysis"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "fpp_ast",
  "fpp_core",
@@ -378,7 +378,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_ast"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "fpp_core",
  "fpp_macros",
@@ -387,7 +387,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_core"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "line-index",
  "rustc-hash 2.1.1",
@@ -396,7 +396,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_diagram"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "clap",
  "fpp_analysis",
@@ -413,7 +413,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_errors"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "annotate-snippets",
  "anstream",
@@ -422,7 +422,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_format"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "clap",
  "fpp_lsp_parser",
@@ -431,14 +431,14 @@ dependencies = [
 
 [[package]]
 name = "fpp_fs"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "fpp_core",
 ]
 
 [[package]]
 name = "fpp_lexer"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "memchr",
  "pretty_assertions",
@@ -447,7 +447,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_lsp_parser"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "drop_bomb",
  "fpp_lexer",
@@ -457,7 +457,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_lsp_server"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "anyhow",
  "clap",
@@ -486,7 +486,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_macros"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -496,7 +496,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_parser"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "fpp_ast",
  "fpp_core",
@@ -509,7 +509,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_python"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "fpp_analysis",
  "fpp_ast",
@@ -525,7 +525,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_python_bindgen"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "rustdoc-json",
  "rustdoc-types",
@@ -535,7 +535,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_python_macros"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -544,7 +544,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_query"
-version = "3.3.24"
+version = "3.3.25"
 dependencies = [
  "anstream",
  "clap",
@@ -561,7 +561,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_util"
-version = "3.3.24"
+version = "3.3.25"
 
 [[package]]
 name = "getopts"

{fprime_fpp_python-3.3.24 → fprime_fpp_python-3.3.25}/Cargo.toml

@@ -4,7 +4,7 @@ members = ["fpp_analysis", "fpp_ast", "fpp_core", "fpp_errors", "fpp_fs", "fpp_l
 resolver = "2"
 
 [workspace.package]
-version = "3.3.24"
+version = "3.3.25"
 edition = "2024"
 authors = ["Andrei Tumbar"]
 license = "Apache-2.0"

{fprime_fpp_python-3.3.24 → fprime_fpp_python-3.3.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-fpp-python
-Version: 3.3.24
+Version: 3.3.25
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Compilers

{fprime_fpp_python-3.3.24 → fprime_fpp_python-3.3.25}/fpp_analysis/Cargo.toml

@@ -13,11 +13,11 @@ repository.workspace = true
 disabled-tests = []
 
 [dependencies]
-fpp_ast = { path = "../fpp_ast", version = "=3.3.24" }
-fpp_core = { path = "../fpp_core", version = "=3.3.24" }
-fpp_util = { path = "../fpp_util", version = "=3.3.24" }
-fpp_macros = { path = "../fpp_macros", version = "=3.3.24" }
-fpp_parser = { path = "../fpp_parser", version = "=3.3.24" }
+fpp_ast = { path = "../fpp_ast", version = "=3.3.25" }
+fpp_core = { path = "../fpp_core", version = "=3.3.25" }
+fpp_util = { path = "../fpp_util", version = "=3.3.25" }
+fpp_macros = { path = "../fpp_macros", version = "=3.3.25" }
+fpp_parser = { path = "../fpp_parser", version = "=3.3.25" }
 rustc-hash = "2.1.1"
 
 [dev-dependencies]

{fprime_fpp_python-3.3.24 → fprime_fpp_python-3.3.25}/fpp_analysis/src/errors.rs

@@ -292,13 +292,22 @@ pub enum SemanticError {
         name: String,
         msg: String,
     },
-    /// Invalid telemetry packet set, reported against one of its channels
-    InvalidTlmPacketSetChannel {
+    /// Telemetry channels of a packet set that are neither used nor marked as
+    /// omitted
+    TlmPacketSetChannelsNotCovered {
         loc: Span,
         name: String,
-        msg: String,
-        /// Locations explaining the error, rendered as span notes
-        notes: Vec<(Span, String)>,
+        /// The qualified names of the uncovered channels, in channel ID order
+        channels: Vec<String>,
+    },
+    /// Telemetry channels of a packet set that are both used and marked as
+    /// omitted
+    TlmPacketSetChannelsUsedAndOmitted {
+        loc: Span,
+        name: String,
+        /// For each channel, its qualified name, a location where it is used,
+        /// and a location where it is marked as omitted, in channel ID order
+        channels: Vec<(String, Span, Span)>,
     },
     /// A telemetry channel identifier that names no channel of the topology
     ChannelNotInDictionary {
@@ -513,6 +522,11 @@ impl SemanticError {
     }
 }
 
+/// Renders `n` as a count of telemetry channels, e.g. `1 telemetry channel`
+fn count_telemetry_channels(n: usize) -> String {
+    format!("{} telemetry channel{}", n, if n == 1 { "" } else { "s" })
+}
+
 impl From<SemanticError> for Diagnostic {
     fn from(val: SemanticError) -> Self {
         match val {
@@ -882,21 +896,36 @@ impl From<SemanticError> for Diagnostic {
                 format!("invalid telemetry packet set {}", name),
             )
             .note(msg),
-            SemanticError::InvalidTlmPacketSetChannel {
-                loc,
-                name,
-                msg,
-                notes,
-            } => {
+            SemanticError::TlmPacketSetChannelsNotCovered { loc, name, channels } => {
+                let diag = Diagnostic::new(
+                    loc,
+                    Level::Error,
+                    format!("invalid telemetry packet set {}", name),
+                )
+                .note(format!(
+                    "{} {} neither used nor marked as omitted",
+                    count_telemetry_channels(channels.len()),
+                    if channels.len() == 1 { "is" } else { "are" },
+                ));
+                channels.into_iter().fold(diag, Diagnostic::note)
+            }
+            SemanticError::TlmPacketSetChannelsUsedAndOmitted { loc, name, channels } => {
                 let diag = Diagnostic::new(
                     loc,
                     Level::Error,
                     format!("invalid telemetry packet set {}", name),
                 )
-                .note(msg);
-                notes
+                .note(format!(
+                    "{} {} both used and marked as omitted",
+                    count_telemetry_channels(channels.len()),
+                    if channels.len() == 1 { "is" } else { "are" },
+                ));
+                channels
                     .into_iter()
-                    .fold(diag, |diag, (loc, note)| diag.span_note(loc, note))
+                    .fold(diag, |diag, (channel, used_loc, omitted_loc)| {
+                        diag.span_note(used_loc, format!("{} is used here", channel))
+                            .span_note(omitted_loc, format!("{} is marked omitted here", channel))
+                    })
             }
             SemanticError::ChannelNotInDictionary {
                 loc,

{fprime_fpp_python-3.3.24 → fprime_fpp_python-3.3.25}/fpp_analysis/src/semantics/tlm_packet.rs

@@ -29,7 +29,7 @@ impl TlmPacket {
 
     /// Gets the location of the packet specifier
     pub fn get_loc(&self) -> Span {
-        self.node.span()
+        self.node.name.span()
     }
 
     /// Creates a telemetry packet from a telemetry packet specifier

fprime_fpp_python-3.3.25/fpp_analysis/src/semantics/tlm_packet_set.rs

@@ -0,0 +1,200 @@
+use crate::Analysis;
+use crate::errors::{SemanticError, SemanticResult};
+use crate::semantics::{Dictionary, TlmChannelEntry, TlmChannelIdentifier, TlmPacket, Topology};
+use fpp_ast::{SpecTlmPacketSet, TlmPacketMember, TlmPacketSetMember};
+use fpp_core::{Span, Spanned};
+use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
+use std::sync::Arc;
+
+/// An FPP telemetry packet set
+#[derive(Debug, Clone)]
+pub struct TlmPacketSet {
+    /// The AST node
+    pub node: Arc<SpecTlmPacketSet>,
+    /// The map from packet IDs to packets
+    pub packet_map: HashMap<i128, TlmPacket>,
+    /// The next default packet ID
+    pub default_packet_id: i128,
+    /// The set of omitted channel IDs
+    pub omitted_id_set: HashSet<i128>,
+    /// The map from each omitted channel ID to a location where the channel is
+    /// marked as omitted. If the channel appears more than once in the omitted
+    /// list in the source model, the map contains the last location.
+    pub omitted_location_map: HashMap<i128, Span>,
+}
+
+impl TlmPacketSet {
+    pub fn new(node: Arc<SpecTlmPacketSet>) -> TlmPacketSet {
+        TlmPacketSet {
+            node,
+            packet_map: HashMap::default(),
+            default_packet_id: 0,
+            omitted_id_set: HashSet::default(),
+            omitted_location_map: HashMap::default(),
+        }
+    }
+
+    /// Gets the name of the packet set
+    pub fn get_name(&self) -> &str {
+        &self.node.name.data
+    }
+
+    /// Gets the location of the packet set specifier
+    pub fn get_loc(&self) -> Span {
+        self.node.name.span()
+    }
+
+    /// Add a telemetry packet to the set
+    pub fn add_packet(&mut self, id_opt: Option<i128>, packet: TlmPacket) -> SemanticResult {
+        let next = Analysis::add_element_to_id_map(
+            &mut self.packet_map,
+            id_opt.unwrap_or(self.default_packet_id),
+            packet,
+            TlmPacket::get_loc,
+        )?;
+        self.default_packet_id = next;
+        Ok(())
+    }
+
+    /// Gets the channels used in the packet set
+    pub fn get_used_id_set(&self) -> HashSet<i128> {
+        self.packet_map
+            .values()
+            .flat_map(|p| p.member_id_list.iter().copied())
+            .collect()
+    }
+
+    /// Gets the used ID location map for the packet set
+    pub fn get_used_id_location_map(&self) -> HashMap<i128, Span> {
+        self.packet_map
+            .values()
+            .flat_map(|p| p.member_location_map.iter().map(|(id, loc)| (*id, *loc)))
+            .collect()
+    }
+
+    /// Completes a telemetry packet set definition
+    pub fn complete(
+        mut self,
+        a: &Analysis,
+        d: &Dictionary,
+        t: &Topology,
+    ) -> SemanticResult<TlmPacketSet> {
+        Analysis::check_dictionary_names(
+            &self.packet_map,
+            "packet",
+            |p| p.get_name().to_string(),
+            TlmPacket::get_loc,
+        )?;
+        self.compute_omitted_channels(a, d, t)?;
+        self.check_channel_usage(d)?;
+        Ok(self)
+    }
+
+    /// Gets the dictionary channels whose IDs are not in `covered_id_set`, in
+    /// channel ID order
+    pub fn get_uncovered_channels<'d>(
+        d: &'d Dictionary,
+        covered_id_set: &HashSet<i128>,
+    ) -> Vec<&'d TlmChannelEntry> {
+        d.tlm_channel_entry_map
+            .iter()
+            .filter(|(id, _)| !covered_id_set.contains(id))
+            .map(|(_, entry)| entry)
+            .collect()
+    }
+
+    /// Gets the channels that the packet set specifier `node` neither uses nor
+    /// marks as omitted, in channel ID order.
+    ///
+    /// Constructing a packet set discards it when a channel is left uncovered,
+    /// so a tool that wants the uncovered channels after the fact (an editor
+    /// quick fix, say) has to recover them from the specifier. Channel
+    /// identifiers that name no channel of the topology are skipped: they are
+    /// reported by their own diagnostic.
+    pub fn get_uncovered_channels_for_node<'d>(
+        a: &Analysis,
+        d: &'d Dictionary,
+        t: &Topology,
+        node: &SpecTlmPacketSet,
+    ) -> Vec<&'d TlmChannelEntry> {
+        let channel_nodes = node
+            .members
+            .iter()
+            .filter_map(|member| match member {
+                TlmPacketSetMember::SpecTlmPacket(packet) => Some(packet),
+                TlmPacketSetMember::SpecInclude(_) => None,
+            })
+            .flat_map(|packet| &packet.members)
+            .filter_map(|member| match member {
+                TlmPacketMember::TlmChannelIdentifier(node) => Some(node),
+                TlmPacketMember::SpecInclude(_) => None,
+            })
+            .chain(&node.omitted);
+        let covered_id_set = channel_nodes
+            .filter_map(|node| {
+                TlmChannelIdentifier::get_numeric_id_for_node(a, d, t, node).unwrap_or(None)
+            })
+            .collect();
+        Self::get_uncovered_channels(d, &covered_id_set)
+    }
+
+    /// Computes the omitted channels of the packet set
+    fn compute_omitted_channels(
+        &mut self,
+        a: &Analysis,
+        d: &Dictionary,
+        t: &Topology,
+    ) -> SemanticResult {
+        for node in &self.node.omitted.clone() {
+            let Some(id) = TlmChannelIdentifier::get_numeric_id_for_node(a, d, t, node)? else {
+                continue;
+            };
+            self.omitted_id_set.insert(id);
+            self.omitted_location_map.insert(id, node.span());
+        }
+        Ok(())
+    }
+
+    /// Checks that each channel is either used or omitted, but not both.
+    ///
+    /// Each check reports every offending channel in one diagnostic: a topology
+    /// that forgets a packet set member typically forgets many, and one error
+    /// per channel would bury the rest of the model's diagnostics.
+    fn check_channel_usage(&self, d: &Dictionary) -> SemanticResult {
+        let used_id_set = self.get_used_id_set();
+        let covered_id_set = used_id_set.union(&self.omitted_id_set).copied().collect();
+        let uncovered_channels = Self::get_uncovered_channels(d, &covered_id_set);
+        if !uncovered_channels.is_empty() {
+            return Err(SemanticError::TlmPacketSetChannelsNotCovered {
+                loc: self.get_loc(),
+                name: self.get_name().to_string(),
+                channels: uncovered_channels
+                    .iter()
+                    .map(|entry| entry.get_qualified_name())
+                    .collect(),
+            });
+        }
+
+        let used_id_location_map = self.get_used_id_location_map();
+        let used_and_omitted_channels: Vec<_> = d
+            .tlm_channel_entry_map
+            .iter()
+            .filter(|(id, _)| used_id_set.contains(id) && self.omitted_id_set.contains(id))
+            .map(|(id, entry)| {
+                (
+                    entry.get_qualified_name(),
+                    used_id_location_map[id],
+                    self.omitted_location_map[id],
+                )
+            })
+            .collect();
+        if !used_and_omitted_channels.is_empty() {
+            return Err(SemanticError::TlmPacketSetChannelsUsedAndOmitted {
+                loc: self.get_loc(),
+                name: self.get_name().to_string(),
+                channels: used_and_omitted_channels,
+            });
+        }
+        Ok(())
+    }
+}

fprime_fpp_python-3.3.24/fpp_analysis/tests/connection_direct/invalid_unmatched_connection.ref.txt → fprime_fpp_python-3.3.25/fpp_analysis/tests/connection_direct/invalid_unmatched_component_connection.ref.txt

@@ -1,4 +1,4 @@
-  --> [ local path prefix ]/connection_direct/invalid_unmatched_connection.fpp:25:15
+  --> [ local path prefix ]/connection_direct/invalid_unmatched_component_connection.fpp:25:15
    |
 25 |     unmatched c1.pOut -> c2.pIn
    |               ^^^^^^^ unmatched connection must go from or to a matched port

fprime_fpp_python-3.3.25/fpp_analysis/tests/connection_direct/invalid_unmatched_topology_connection.fpp

@@ -0,0 +1,37 @@
+port P
+
+passive component C1 {
+
+  output port pOut: P
+
+}
+
+passive component C2 {
+
+  sync input port pIn: P
+
+}
+
+instance c1: C1 base id 0x100
+instance c2: C2 base id 0x200
+
+topology S {
+
+  instance c2
+
+  port c2_pIn = c2.pIn
+
+}
+
+topology T {
+
+  instance c1
+  instance S
+
+  connections C {
+
+    unmatched c1.pOut -> S.c2_pIn
+
+  }
+
+}

fprime_fpp_python-3.3.25/fpp_analysis/tests/connection_direct/invalid_unmatched_topology_connection.ref.txt

@@ -0,0 +1,5 @@
+  --> [ local path prefix ]/connection_direct/invalid_unmatched_topology_connection.fpp:33:15
+   |
+33 |     unmatched c1.pOut -> S.c2_pIn
+   |               ^^^^^^^ unmatched connection must go from or to a matched port
+

{fprime_fpp_python-3.3.24 → fprime_fpp_python-3.3.25}/fpp_analysis/tests/connection_direct/ok.fpp

@@ -25,6 +25,22 @@ passive component C5 {
   sync input port pIn: [4] P
 }
 
+instance c3_s: C3 base id 0x600
+instance c4_s: C4 base id 0x700
+instance c5_s: C5 base id 0x800
+
+topology S {
+  instance c3_s
+  instance c4_s
+  instance c5_s
+
+  port c3_pIn = c3_s.pIn
+  port c3_pOut = c3_s.pOut
+  port c4_pIn = c4_s.pIn
+  port c5_pIn = c5_s.pIn
+  port c5_pOut = c5_s.pOut
+}
+
 instance c1: C1 base id 0x100
 instance c2: C2 base id 0x200
 instance c3: C3 base id 0x300
@@ -37,6 +53,7 @@ topology T {
   instance c3
   instance c4
   instance c5
+  instance S
 
   connections C {
 
@@ -44,14 +61,22 @@ topology T {
     c1.serialOut -> c2.pIn
     c1.pOut -> c2.serialIn
     c1.serialOut -> c2.serialIn
-    
-    # Matched connections to matched ports (c3.pOut, c3.pIn)
+
+    # Matched connections to matched component instance ports
     c3.pOut -> c5.pIn
     c5.pOut -> c3.pIn
 
-    # Unmatched connections to matched ports (c3.pOut, c3.pIn)
+    # Matched connections to matched topology ports
+    S.c3_pOut -> S.c5_pIn
+    S.c5_pOut -> S.c3_pIn
+
+    # Unmatched connections to matched component instance ports
     unmatched c3.pOut[0] -> c4.pIn[0]
     unmatched c3.pOut -> c4.pIn
 
+    # Unmatched connections to matched topology ports
+    unmatched S.c3_pOut[0] -> S.c4_pIn[0]
+    unmatched S.c3_pOut -> S.c4_pIn
+
   }
 }

{fprime_fpp_python-3.3.24 → fprime_fpp_python-3.3.25}/fpp_analysis/tests/connection_direct/test.rs

@@ -41,8 +41,13 @@ fn mismatched_port_types() {
 }
 
 #[test]
-fn invalid_unmatched_connection() {
-    run_test("connection_direct/invalid_unmatched_connection")
+fn invalid_unmatched_component_connection() {
+    run_test("connection_direct/invalid_unmatched_component_connection")
+}
+
+#[test]
+fn invalid_unmatched_topology_connection() {
+    run_test("connection_direct/invalid_unmatched_topology_connection")
 }
 
 #[test]

fprime_fpp_python-3.3.25/fpp_analysis/tests/tlm_packets/channel_neither_used_nor_omitted.ref.txt

@@ -0,0 +1,8 @@
+ --> [ local path prefix ]/tlm_packets/channel_neither_used_nor_omitted.fpp:5:21
+  |
+5 |   telemetry packets P {
+  |                     ^ invalid telemetry packet set P
+  |
+  = note: 1 telemetry channel is neither used nor marked as omitted
+  = note: c1.T
+

fprime_fpp_python-3.3.25/fpp_analysis/tests/tlm_packets/channel_used_and_omitted.ref.txt

@@ -0,0 +1,17 @@
+  --> [ local path prefix ]/tlm_packets/channel_used_and_omitted.fpp:5:21
+   |
+ 5 |   telemetry packets P {
+   |                     ^ invalid telemetry packet set P
+   |
+   = note: 1 telemetry channel is both used and marked as omitted
+   |
+  ::: [ local path prefix ]/tlm_packets/channel_used_and_omitted.fpp:8:7
+   |
+ 8 |       c1.T
+   |       ---- c1.T is used here
+   |
+  ::: [ local path prefix ]/tlm_packets/channel_used_and_omitted.fpp:12:5
+   |
+12 |     c1.T
+   |     ---- c1.T is marked omitted here
+

fprime_fpp_python-3.3.25/fpp_analysis/tests/tlm_packets/channels_neither_used_nor_omitted.fpp

@@ -0,0 +1,17 @@
+deployment topology T {
+
+  instance c1
+
+  instance c2
+
+  instance c3
+
+  telemetry packets P {
+
+    packet P group 0 {
+      c2.T
+    }
+
+  }
+
+}

fprime_fpp_python-3.3.25/fpp_analysis/tests/tlm_packets/channels_neither_used_nor_omitted.ref.txt

@@ -0,0 +1,9 @@
+ --> [ local path prefix ]/tlm_packets/channels_neither_used_nor_omitted.fpp:9:21
+  |
+9 |   telemetry packets P {
+  |                     ^ invalid telemetry packet set P
+  |
+  = note: 2 telemetry channels are neither used nor marked as omitted
+  = note: c1.T
+  = note: c3.T
+

fprime_fpp_python-3.3.25/fpp_analysis/tests/tlm_packets/duplicate_id_explicit.ref.txt

@@ -0,0 +1,10 @@
+  --> [ local path prefix ]/tlm_packets/duplicate_id_explicit.fpp:12:12
+   |
+12 |     packet P2 id 0 group 1 {
+   |            ^^ duplicate identifier value (0 dec, 0 hex)
+   |
+  ::: [ local path prefix ]/tlm_packets/duplicate_id_explicit.fpp:8:12
+   |
+ 8 |     packet P1 id 0 group 0 {
+   |            -- previous occurrence is here
+