fusible 0.11.6

Electronic linter: a fuse that blows to block firmware code generation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Connectivity first: every net, port and trace joins one disjoint-set
//! forest, and nets are cut from its components afterwards.

use std::collections::HashMap;

use super::labels::{synthetic_id, trace_label};
use super::union_find::UnionFind;
use super::DanglingRef;
use crate::parser::{Circuit, Port, Trace};

pub(super) type PortMap<'a> = HashMap<&'a str, &'a Port>;

pub(super) struct TraceJoin {
    pub label: String,
    pub anchor: usize,
}

#[derive(Default)]
pub(super) struct Connectivity {
    pub sets: UnionFind,
    pub net_ids: Vec<(usize, String)>,
    net_nodes: HashMap<String, usize>,
    port_nodes: HashMap<String, usize>,
    pub declared: HashMap<String, Option<String>>,
    pub synthetic: HashMap<String, Option<String>>,
    pub refs: HashMap<String, usize>,
    pub traces: Vec<TraceJoin>,
    pub short_joins: Vec<TraceJoin>,
    pub declared_nodes: Vec<usize>,
    pub dangling: Vec<DanglingRef>,
}

impl Connectivity {
    pub(super) fn from_circuit(
        circuit: &Circuit,
        ports: &PortMap<'_>,
    ) -> (Self, Vec<Option<usize>>) {
        let mut graph = Self::default();
        for net in circuit.nets() {
            if let Some(id) = net.net_id.as_deref() {
                let node = graph.net(id);
                graph.declared_nodes.push(node);
                graph.declared.insert(id.to_string(), net.name.clone());
            }
        }
        let anonymous = circuit.ports().map(|p| graph.join_port(p)).collect();
        for (index, trace) in circuit.traces().enumerate() {
            graph.join_trace(index, trace, ports);
        }
        graph.join_pads(circuit, ports);
        (graph, anonymous)
    }

    pub(super) fn port_node(&self, port: &Port, joined: Option<usize>) -> Option<usize> {
        joined.or_else(|| self.port_nodes.get(port.port_id.as_deref()?).copied())
    }

    pub(super) fn net(&mut self, id: &str) -> usize {
        if let Some(&node) = self.net_nodes.get(id) {
            return node;
        }
        let node = self.sets.add();
        self.net_nodes.insert(id.to_string(), node);
        self.net_ids.push((node, id.to_string()));
        node
    }

    pub(super) fn port(&mut self, id: Option<&str>) -> usize {
        let Some(id) = id else {
            return self.sets.add();
        };
        if let Some(&node) = self.port_nodes.get(id) {
            return node;
        }
        let node = self.sets.add();
        self.port_nodes.insert(id.to_string(), node);
        node
    }

    pub(super) fn reference(&mut self, net_id: &str) {
        *self.refs.entry(net_id.to_string()).or_default() += 1;
    }

    fn join_port(&mut self, port: &Port) -> Option<usize> {
        let net_id = port.net_id.as_deref()?;
        let node = self.port(port.port_id.as_deref());
        let net = self.net(net_id);
        let label = format!("source_port \"{}\"", port.port_id.as_deref().unwrap_or("?"));
        self.link(node, net, &label);
        self.reference(net_id);
        Some(node)
    }

    fn trace_ports(&mut self, label: &str, trace: &Trace, ports: &PortMap<'_>) -> Vec<usize> {
        let mut nodes = Vec::new();
        for port_id in &trace.connected_source_port_ids {
            if ports.contains_key(port_id.as_str()) {
                nodes.push(self.port(Some(port_id)));
            } else {
                self.dangling.push(DanglingRef {
                    owner: label.to_string(),
                    target: format!("source_port \"{port_id}\""),
                });
            }
        }
        nodes
    }

    fn join_trace(&mut self, index: usize, trace: &Trace, ports: &PortMap<'_>) {
        let label = trace_label(trace, index);
        let mut nodes = self.trace_ports(&label, trace, ports);
        let port_only = trace.connected_source_net_ids.is_empty() && !nodes.is_empty();
        for net_id in &trace.connected_source_net_ids {
            nodes.push(self.net(net_id));
            self.reference(net_id);
        }
        if port_only {
            let id = synthetic_id(trace, index);
            nodes.push(self.net(&id));
            self.reference(&id);
            self.synthetic
                .entry(id)
                .or_insert_with(|| trace.name.clone());
        }
        let Some(&anchor) = nodes.first() else {
            return;
        };
        for &node in &nodes {
            self.link(anchor, node, &label);
        }
        self.traces.push(TraceJoin { label, anchor });
    }
}