@h2loop/autosar 1.5.3 → 1.6.0

package/python/ecuc_engine/add_like.py

@@ -0,0 +1,471 @@
+"""autosar_add_like: add a new X like an existing Y, end to end, across all ARXML (ECUC + System/SWC), or refuse.
+
+Projects name the elements of one thing after it: a message BCM_DoorStatus is the frame BCM_DoorStatus_CanFrame,
+the I-PDU, the PDU/frame triggerings, the EcuC Pdu, the CanIf TX PDU, the PduR routing path and the Com I-PDU, all
+linked by references. Cloning that chain, renamed, gives a new message that is consistent with the project's own
+conventions, in every file at once. The same works for a port, a runnable with its event, a Dem event, an NvM
+block, a calibration parameter: whatever the template's chain is.
+
+  chain    elements whose SHORT-NAME contains `like` and that are linked to each other by references
+           (`seed` picks the chain when several unconnected ones carry the stem)
+  members  inside a cloned element, sub-elements whose name lacks the stem and that refer to elements outside the
+           chain (a message's signal mappings, an I-PDU's ComIPduSignalRefs) are the template's own content: they
+           are not copied (`keep_members=true` copies them)
+  links    a list outside the chain that refers to a chain element (ECU-extract FIBEX elements, ...) gets an entry
+           for the clone; a single-valued slot is reported, not changed
+  ids      ECUC *HandleId / *PduId values get the lowest unused value of that parameter
+  set      {"ParamDefName" | "XML-TAG" | "Owner:key": value} applied to the clones (Owner = part of a clone's
+           SHORT-NAME or its tag); every key must match at least one value
+Everything is checked (schema, every reference + DEST) and validated before/after; any new finding rolls back.
+"""
+from __future__ import annotations
+
+import collections
+import os
+import re
+import uuid
+from typing import Optional
+
+from .arxml_edit import ArxmlEditor, FileTree, _ad
+from .model import Project
+from .xmltree import escape, line_indent
+
+REF_TAG = re.compile(r"(?:-REF|-TREF|-IREF|^VALUE-REF)$")
+REGISTRY_MIN = 12  # a holder with this many outgoing references is a list of everything, not an owner
+OWNER_DEST = re.compile(r"(?:PORT-PROTOTYPE|RUNNABLE-ENTITY|COMPONENT-PROTOTYPE|SW-COMPONENT-TYPE|INTERNAL-BEHAVIOR)$")
+# Handle IDs exactly as validation sees them (rules/handles.py): with param defs, an integer with SYMBOLIC-NAME-VALUE;
+# without defs, by name.
+from .rules.handles import NAME as HANDLE_NAME  # noqa: E402
+
+
+class AddLikeError(Exception):
+    pass
+
+
+def _is_ref(node) -> bool:
+    """A reference to another configured/modelled element (not DEFINITION-REF, which points at the param def)."""
+    return bool(REF_TAG.search(node.tag)) and not node.children and node.tag != "DEFINITION-REF"
+
+
+def _holder(node):
+    """Nearest ancestor (or self) that has a SHORT-NAME: the identifiable that owns a reference."""
+    n = node.parent
+    while n is not None and n.short_name is None:
+        n = n.parent
+    return n
+
+
+class Graph:
+    def __init__(self, ed: ArxmlEditor, files: list):
+        self.ed = ed
+        self.trees = {}
+        self.where = {}        # path -> (file, node)
+        self.path_of = {}      # id(node) -> path
+        self.refs = []         # (file, ref node, holder path, target)
+        for f in files:
+            try:
+                ft = ed.load(f)
+            except Exception:  # noqa: BLE001 -- unparseable files are left alone
+                continue
+            self.trees[f] = ft
+            for p, n in ft.by_path.items():
+                self.where.setdefault(p, (f, n))
+                self.path_of[id(n)] = p
+        for f, ft in self.trees.items():
+            for n in ft.root.iter():
+                if _is_ref(n):
+                    t = n.text.strip()
+                    h = _holder(n)
+                    hp = self.path_of.get(id(h)) if h is not None else None
+                    if t.startswith("/") and hp:
+                        self.refs.append((f, n, hp, t))
+        self.referrers = collections.defaultdict(list)
+        self.out = collections.defaultdict(list)
+        for f, n, hp, t in self.refs:
+            self.referrers[t].append((f, n, hp))
+            self.out[hp].append((t, n.attrs.get("DEST", "")))
+
+    @staticmethod
+    def name(path: str) -> str:
+        return path.rsplit("/", 1)[-1]
+
+    def under(self, path: str, roots) -> bool:
+        return any(path == r or path.startswith(r + "/") for r in roots)
+
+
+def _chain(g: Graph, pairs: list, seed: Optional[str]) -> list:
+    stems = [a for a, _ in pairs]
+    stem = pairs[-1][0] if len(pairs) == 1 else " / ".join(stems)
+    cands = {p for p in g.where if any(a in Graph.name(p) for a in stems)}
+    if not cands:
+        raise AddLikeError(f"no element's SHORT-NAME contains {stem!r}")
+    for a in stems:
+        if not any(a in Graph.name(p) for p in cands):
+            raise AddLikeError(f"no element's SHORT-NAME contains {a!r}")
+    adj = collections.defaultdict(set)
+    for f, n, hp, t in g.refs:
+        a = next((x for x in _ancestors(hp) if x in cands), None)
+        b = next((x for x in _ancestors(t) if x in cands), None)
+        if a and b and a != b:
+            adj[a].add(b)
+            adj[b].add(a)
+    for p in cands:  # containment links a named child to a named parent
+        par = next((x for x in _ancestors(p)[1:] if x in cands), None)
+        if par:
+            adj[p].add(par)
+            adj[par].add(p)
+    comps, seen = [], set()
+    for p in sorted(cands):
+        if p in seen:
+            continue
+        comp, todo = set(), [p]
+        while todo:
+            x = todo.pop()
+            if x in comp:
+                continue
+            comp.add(x)
+            todo.extend(adj[x] - comp)
+        seen |= comp
+        comps.append(comp)
+    if seed:
+        comps = [c for c in comps if any(seed == x or x.endswith("/" + seed.strip("/")) or seed.strip("/") == Graph.name(x)
+                                         for x in c)]
+        if not comps:
+            raise AddLikeError(f"seed {seed!r} is not an element whose SHORT-NAME contains {stem!r}")
+    if len(stems) > 1:   # the template and its named members must form ONE chain
+        comps = [c for c in comps if all(any(a in Graph.name(x) for x in c) for a in stems)] or comps
+    linked = [c for c in comps if len(c) > 1] or comps
+    if len(linked) > 1:
+        heads = ["; ".join(sorted(c)[:3]) for c in sorted(linked, key=len, reverse=True)[:6]]
+        raise AddLikeError(f"{len(linked)} separate chains carry {stem!r}; pass seed = one element of the one you mean: "
+                           + " | ".join(heads))
+    comp = set(linked[0])
+    # A member of the template (named after an `also` stem, not the main one) that points at an outside element
+    # OWNING something (a port, runnable, component, behavior) belongs to that owner, not to the template: e.g. the
+    # write access of the OLD port to a data element of the cloned interface. Leave it out.
+    main = pairs[0][0] if len(pairs) == 1 else next(a for a, _ in pairs if a == g.main)
+    named = lambda x: any(a in Graph.name(x) for a in stems)  # noqa: E731
+    mains = {p for p in comp if main in Graph.name(p)}
+    for p in sorted(comp):
+        if p in mains or any(a in mains for a in _ancestors(p)[1:]):
+            continue
+        outs = [(t, d) for hp, lst in g.out.items() if hp == p or hp.startswith(p + "/") for t, d in lst]
+        if any(OWNER_DEST.search(d or "") and not named(t) and not any(t == c or t.startswith(c + "/") for c in comp)
+               for t, d in outs):
+            comp.discard(p)
+    return sorted(p for p in comp if not any(a in comp for a in _ancestors(p)[1:]))  # top-most only
+
+
+def _ancestors(path: str) -> list:
+    segs = path.strip("/").split("/")
+    return ["/" + "/".join(segs[:i]) for i in range(len(segs), 0, -1)]
+
+
+def _multi(project: Project, ref, wrapper) -> bool:
+    """Whether a reference sits in a multi-valued slot (a list the clone can leave out of)."""
+    if wrapper.tag.endswith("REFERENCE-VALUE"):
+        dr = wrapper.child("DEFINITION-REF")
+        d = project.defs.get(dr.text.strip()) if (dr is not None and project.defs) else None
+        if d is not None:
+            return d.upper is None or d.upper > 1
+        return False   # without the def, assume single and keep it
+    return wrapper.parent is not None and wrapper.parent.tag.endswith("S")
+
+
+def _wrapper(node, holder):
+    """The smallest element around a reference that can be repeated on its own (ECUC-REFERENCE-VALUE, *-CONDITIONAL)."""
+    if node.parent is not None and node.parent.tag.endswith("REFERENCE-VALUE") and \
+            all(c is node or c.tag == "DEFINITION-REF" for c in node.parent.children):
+        return node.parent  # ECUC: the whole ECUC-(INSTANCE-)REFERENCE-VALUE entry
+    w = node
+    while w.parent is not None and w.parent is not holder and len(w.parent.children) == 1 and not w.parent.tag.endswith("S"):
+        w = w.parent
+    return w
+
+
+def add_like(project: Project, like: str, name: str, seed: Optional[str] = None, set_values: Optional[dict] = None,
+             keep_members: bool = False, dry_run: bool = False, also: Optional[dict] = None) -> dict:
+    """also = {template member stem: new stem}, e.g. {"DrvDoorOpenSts": "SettingsAckCounter"}: those members of the
+    template (a signal of the message, a data element of the interface, ...) are cloned and renamed too."""
+    from .validate import validate
+    stem, new = (like or "").strip(), (name or "").strip()
+    if not stem or not new:
+        raise AddLikeError("like (the name stem of an existing element, e.g. BCM_DoorStatus) and name (the new stem) "
+                           "are both required")
+    pairs = [(stem, new)] + [(str(a).strip(), str(b).strip()) for a, b in (also or {}).items()]
+    for a, b in pairs:
+        if not a or not re.fullmatch(r"[A-Za-z_]\w*", b):
+            raise AddLikeError(f"{a!r} -> {b!r}: the new name must be a valid SHORT-NAME")
+    pairs.sort(key=lambda x: len(x[0]), reverse=True)  # longer stems first, so one does not eat another
+    ed = ArxmlEditor(project)
+    files = list(project.sources.config) + list(project.sources.input)
+    g = Graph(ed, files)
+    g.main = stem
+    chain = _chain(g, pairs, seed)
+    newpaths = {p: _rn(p, pairs) for p in chain}
+    clash = [q for q in newpaths.values() if q in g.where]
+    if clash:
+        raise AddLikeError(f"already exists: {', '.join(clash[:5])}")
+    chain_roots = set(chain)
+    in_chain = lambda t: g.under(t, chain_roots)  # noqa: E731
+    # The template's OWN content: targets referenced only from the chain, or only from other such targets
+    # (a message's I-SIGNAL is referenced by its mapping and by its I-SIGNAL-TRIGGERING, which only the message's
+    # PDU triggering references). Shared things (a debounce class used by every Dem event) are never "own".
+    # Registries (an ECU extract's FIBEX-ELEMENTS, an ECUC value collection: one holder listing many elements) say
+    # nothing about ownership and are ignored here; they are still linked for the clones below.
+    registry = {hp for hp, lst in g.out.items() if len(lst) >= REGISTRY_MIN}
+    targets = {t for _, _, _, t in g.refs if not in_chain(t)}
+    exclusive: set = set()
+    grew = True
+    while grew:
+        grew = False
+        for t in targets - exclusive:
+            owners = [hp for _, _, hp in g.referrers[t] if hp not in registry]
+            if owners and all(g.under(hp, chain_roots) or g.under(hp, exclusive) for hp in owners):
+                exclusive.add(t)
+                grew = True
+    named = lambda p: any(a in Graph.name(p) for a, _ in pairs)  # noqa: E731
+    notes, dropped, linked, single = [], [], [], []
+    before = {_dkey(d) for d in validate(project, check_generated=False)["diagnostics"]
+              if d["severity"] in ("error", "warning")}
+
+    # ---------- clone every chain element next to its template ----------
+    inserts = collections.defaultdict(list)  # file -> [(end offset, bytes)]
+    for p in chain:
+        f, node = g.where[p]
+        ft = g.trees[f]
+        data = ft.data
+        cuts = []  # (start, end) byte spans inside the element to leave out
+        if not keep_members:
+            for d in node.iter():
+                if d is node:
+                    continue
+                dp = g.path_of.get(id(d))
+                if dp and not named(dp):
+                    outside = [t for t in _refs_below(d) if t in exclusive and not named(t)]
+                    if outside and not any(c[0] <= d.start < c[1] for c in cuts):
+                        cuts.append((_line_start(data, d.start), d.end))
+                        dropped.append(f"{_rn(dp, pairs)} (the template's {d.tag} {Graph.name(dp)})")
+                elif _is_ref(d) and not any(c[0] <= d.start < c[1] for c in cuts):
+                    t = d.text.strip()
+                    if t in exclusive and not named(t):
+                        w = _wrapper(d, _holder(d))
+                        if not _multi(project, d, w):   # a single slot (CanIfTxPduBufferRef): keep, it is shared now
+                            notes.append(f"{_rn(g.path_of.get(id(_holder(d)), ''), pairs)}: {d.tag} still -> {t} "
+                                         "(the template's; single-valued, so the clone shares it; change it if it must not)")
+                        elif w is not d or d.parent.tag.endswith("S"):
+                            if not any(c[0] <= w.start < c[1] for c in cuts):
+                                cuts.append((_line_start(data, w.start), w.end))
+                                dropped.append(f"{d.tag} -> {t} (the template's own member)")
+        text = _excise(data, node.start, node.end, cuts).decode("utf-8")
+        text = _retext(text, pairs, in_chain)
+        ind = line_indent(data, node.start) or b""
+        inserts[f].append((node.end, ft.nl + ind + text.encode("utf-8")))
+
+    # ---------- link the clones where the template is listed ----------
+    for p in chain:
+        for f, n, hp in g.referrers.get(p, []):
+            if g.under(hp, chain_roots):
+                continue
+            ft = g.trees[f]
+            holder = _holder(n)
+            w = _wrapper(n, holder)
+            repeatable = w.parent is not None and (w.parent.tag.endswith("S") or w is not n)
+            if not repeatable:
+                single.append(f"{hp}: {n.tag} -> {p} (single-valued; not changed)")
+                continue
+            t = ft.data[w.start:w.end].decode("utf-8").replace(f">{p}<", f">{newpaths[p]}<")
+            t = re.sub(r'\sUUID="[^"]*"', lambda _m: f' UUID="{uuid.uuid4()}"', t)
+            ind = line_indent(ft.data, w.start) or b""
+            inserts[f].append((w.end, ft.nl + ind + t.encode("utf-8")))
+            linked.append(f"{hp}: {n.tag} -> {newpaths[p]}")
+
+    for f, ins in inserts.items():
+        data = g.trees[f].data
+        for off, b in sorted(ins, key=lambda x: x[0], reverse=True):
+            data = data[:off] + b + data[off:]
+        ed.files[f] = FileTree(f, data)
+
+    # ---------- handle ids + requested values ----------
+    created = sorted(newpaths.values())
+    ids = _assign_ids(ed, created)
+    applied = _apply_set(ed, created, set_values or {})
+
+    probs = ed.check()
+    changes = {f: ft.data for f, ft in ed.files.items() if ft.data != ed.original.get(f)}
+    res = {"like": stem, "name": new, "created": created, "linked": linked, "notCopied": dropped,
+           "singleValuedNotLinked": single, "ids": ids, "set": applied, "files": sorted(project.rel(f) for f in changes),
+           "notes": notes}
+    if probs:
+        return {**res, "ok": False, "written": False, "error": "the clone would leave broken ARXML; nothing written",
+                "problems": probs[:20]}
+    if dry_run:
+        return {**res, "ok": True, "written": False}
+    originals = {f: ed.original[f] for f in changes}
+    for f, b in changes.items():
+        with open(f, "wb") as fh:
+            fh.write(b)
+    after = validate(Project(project.root, project.sources.config, project.sources.defs), check_generated=False)
+    fresh = [d for d in after["diagnostics"] if d["severity"] in ("error", "warning")
+             and _dkey(d) not in before]
+    if fresh:
+        for f, b in originals.items():
+            with open(f, "wb") as fh:
+                fh.write(b)
+        return {**res, "ok": False, "written": False, "error": "validation found new problems; all changes rolled back",
+                "diagnostics": fresh[:20]}
+    return {**res, "ok": True, "written": True, "validation": after["summary"],
+            "next": "check each created element against the request (ecuc_read / the diff), set what is still the "
+                    "template's (ecuc_edit / arxml_edit), add the new signals (autosar_add_signal), then regenerate "
+                    "and build"}
+
+
+def _rn(path: str, pairs, new: Optional[str] = None) -> str:
+    if isinstance(pairs, str):
+        pairs = [(pairs, new)]
+    out = []
+    for seg in path.split("/"):
+        for a, b in pairs:
+            if a in seg:
+                seg = seg.replace(a, b)
+                break
+        out.append(seg)
+    return "/".join(out)
+
+
+def _refs_below(node) -> list:
+    return [d.text.strip() for d in node.iter() if _is_ref(d) and d.text.strip().startswith("/")]
+
+
+def _line_start(data: bytes, pos: int) -> int:
+    if line_indent(data, pos) is not None:
+        nl = data.rfind(b"\n", 0, pos)
+        return nl if nl >= 0 else pos
+    return pos
+
+
+def _excise(data: bytes, start: int, end: int, cuts: list) -> bytes:
+    out, at = [], start
+    for a, b in sorted(c for c in cuts if start <= c[0] and c[1] <= end):
+        if a < at:
+            continue
+        out.append(data[at:a])
+        at = b
+    out.append(data[at:end])
+    return b"".join(out)
+
+
+def _retext(text: str, pairs: list, in_chain) -> str:
+    """Rename the stems in SHORT-NAMEs and in references into the chain; fresh UUIDs."""
+    text = re.sub(r"(<SHORT-NAME>)([^<]*)(</SHORT-NAME>)", lambda m: m.group(1) + _rn(m.group(2), pairs) + m.group(3), text)
+
+    def ref(m):
+        t = m.group(2).strip()
+        return m.group(1) + (_rn(t, pairs) if in_chain(t) else m.group(2)) + m.group(3)
+    text = re.sub(r"(<[A-Z0-9-]*(?:-REF|-TREF|-IREF|VALUE-REF)\b[^>]*>)([^<]*)(</)", ref, text)
+    return re.sub(r'\sUUID="[^"]*"', lambda _m: f' UUID="{uuid.uuid4()}"', text)
+
+
+def _num_values(ft: FileTree, root):
+    """(DEFINITION-REF, def short name, VALUE node) for each ECUC numerical value below root."""
+    for n in root.iter():
+        if n.tag == "ECUC-NUMERICAL-PARAM-VALUE":
+            d = n.child("DEFINITION-REF")
+            v = n.child("VALUE")
+            if d is not None and v is not None:
+                yield d.text.strip(), d.text.strip().rsplit("/", 1)[-1], v
+
+
+def _is_handle(project: Project, defref: str, name: str) -> bool:
+    d = project.defs.get(defref) if project.defs else None
+    if d is not None:
+        return d.kind == "INTEGER" and bool(d.symbolic_name)
+    return bool(HANDLE_NAME.search(name))
+
+
+def _range(project: Project, defref: str) -> tuple:
+    d = project.defs.get(defref) if project.defs else None
+    lo, hi = 0, (1 << 16) - 1
+    try:
+        if d is not None and d.min not in (None, ""):
+            lo = int(str(d.min), 0) + (1 if d.min_open else 0)
+        if d is not None and d.max not in (None, ""):
+            hi = min(hi, int(str(d.max), 0) - (1 if d.max_open else 0))
+    except ValueError:
+        pass
+    return max(lo, 0), hi
+
+
+def _assign_ids(ed: ArxmlEditor, created: list) -> list:
+    out = []
+    for p in created:
+        ft, node = ed.tree_for(p)
+        todo = [(dr, dn) for dr, dn, _ in _num_values(ft, node) if _is_handle(ed.p, dr, dn)]
+        for k, (dr, dn) in enumerate(todo):
+            ft, node = ed.tree_for(p)  # positions move after each patch
+            mine = [v for r, _, v in _num_values(ft, node) if r == dr]
+            target = mine[min(k - sum(1 for x in todo[:k] if x[0] != dr), len(mine) - 1)] if mine else None
+            if target is None:
+                continue
+            used = set()
+            for ft2 in ed.files.values():
+                for r2, _, v2 in _num_values(ft2, ft2.root):
+                    if r2 == dr and not (ft2 is ft and v2.start == target.start):
+                        try:
+                            used.add(int(v2.text.strip(), 0))
+                        except ValueError:
+                            pass
+            lo, hi = _range(ed.p, dr)
+            nid = next((i for i in range(lo, hi + 1) if i not in used), None)
+            if nid is None:
+                raise AddLikeError(f"no free {dn} value in [{lo}..{hi}]")
+            ed.patch(ft, target.start, target.end, f"<VALUE>{nid}</VALUE>".encode())
+            out.append(f"{p}/{dn} = {nid}")
+    return out
+
+
+def _apply_set(ed: ArxmlEditor, created: list, values: dict) -> list:
+    applied = []
+    for key, value in values.items():
+        owner, _, k = str(key).rpartition(":")
+        hits = 0
+        for p in created:
+            done = 0
+            while True:
+                ft, node = ed.tree_for(p)   # re-read: every patch moves the byte offsets
+                cands = []
+                for c in _value_nodes(ft, node, k):
+                    h = _holder(c) or node
+                    hp = next((q for q, n in ft.by_path.items() if n is h), p)
+                    if not owner or owner in hp.rsplit("/", 1)[-1] or owner.upper() == h.tag:
+                        cands.append((c, hp))
+                if done >= len(cands):
+                    break
+                c, hp = cands[done]
+                ed.patch(ft, c.start, c.end, f"<{c.tag}>{escape(str(value))}</{c.tag}>".encode())
+                applied.append(f"{hp}/{k} = {value}")
+                done += 1
+                hits += 1
+        if not hits:
+            raise AddLikeError(f"set {key!r}: no ECUC parameter or element {k!r} in the cloned elements "
+                               f"({', '.join(created[:6])}); use the parameter's definition name or the XML tag")
+    return applied
+
+
+def _value_nodes(ft: FileTree, root, key: str) -> list:
+    """VALUE nodes of ECUC params named `key` and leaf elements tagged `key` below root."""
+    out = []
+    for n in root.iter():
+        if n.tag in ("ECUC-NUMERICAL-PARAM-VALUE", "ECUC-TEXTUAL-PARAM-VALUE"):
+            d, v = n.child("DEFINITION-REF"), n.child("VALUE")
+            if d is not None and v is not None and d.text.strip().rsplit("/", 1)[-1] == key:
+                out.append(v)
+        elif n.tag == key.upper() and not n.children and n.tag != "SHORT-NAME":
+            out.append(n)
+    return out
+
+
+def _dkey(d: dict) -> tuple:
+    """A finding without line numbers (file.arxml:123), so one that only moved because text was inserted above it
+    is not taken for a new one."""
+    return d["rule"], d["path"], re.sub(r"(\.arxml|\.ARXML|\.dbc):\d+", r"\1", d["message"])

package/python/ecuc_engine/add_signal.py

@@ -95,7 +95,7 @@ def add_signal(project: Project, name: str, ipdu: str, bit_size: Optional[int] =
     sib = next((m for m in members if m is not None and (m.def_ref or "").endswith("/ComSignal")), None)
     if sib is None:
         raise AddSignalError(f"{ip.name} has no ComSignal to use as template")
-    before = {(d["rule"], d["path"], d["message"]) for d in validate(project, check_generated=False)["diagnostics"]
+    before = {_dkey(d) for d in validate(project, check_generated=False)["diagnostics"]
               if d["severity"] in ("error", "warning")}
     notes: list = []
 
@@ -209,7 +209,7 @@ def add_signal(project: Project, name: str, ipdu: str, bit_size: Optional[int] =
     # same inputs as `before` (explicit --defs/--config included), so only the edit's own findings count as new
     after = validate(Project(project.root, project.sources.config, project.sources.defs), check_generated=False)
     new = [d for d in after["diagnostics"] if d["severity"] in ("error", "warning")
-           and (d["rule"], d["path"], d["message"]) not in before]
+           and _dkey(d) not in before]
     if new:
         for f, b in originals.items():
             with open(f, "wb") as fh:
@@ -397,3 +397,9 @@ def _dbc_line(project: Project, pdu, name, pos, size, endian, typ, notes, member
             out[f] = (text[:block_end] + line + text[block_end:]).encode()
             notes.append(f"added SG_ {name} to BO_ {m.group(1)} {m.group(2)} in {project.rel(f)}")
     return out
+
+
+def _dkey(d: dict) -> tuple:
+    """A finding without line numbers (file.arxml:123), so one that only moved because text was inserted above it
+    is not taken for a new one."""
+    return d["rule"], d["path"], re.sub(r"(\.arxml|\.ARXML|\.dbc):\d+", r"\1", d["message"])