backhopper-xref-graph 0.27.0

Whole-program call-graph primitives for backhopper-xref: vertices, relations, set algebra, transitive closure
Documentation 
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

// Copyright (C) 2026 Michael S. Klishin and Contributors
// SPDX-License-Identifier: Apache-2.0 OR MIT
// See LICENSE-APACHE and LICENSE-MIT for details.

//! Source locations.
//!
//! Locations are spans, not points, so multi-line call sites can be
//! reported verbatim. Paths are interned per [`CallGraph`](crate::graph::CallGraph)
//! to avoid storing thousands of duplicate `PathBuf`s on the edge set.

use std::collections::HashMap;
use std::path::{Path, PathBuf};

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(transparent)]
pub struct PathId(u32);

impl PathId {
    pub const fn new(id: u32) -> Self {
        Self(id)
    }

    pub const fn as_u32(self) -> u32 {
        self.0
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub struct Position {
    pub line: u32,
    pub column: u32,
    pub byte_offset: u32,
}

impl Position {
    pub const fn new(line: u32, column: u32, byte_offset: u32) -> Self {
        Self {
            line,
            column,
            byte_offset,
        }
    }

    /// `(1, 1, 0)`: the canonical "start of file" position.
    pub const fn zero() -> Self {
        Self::new(1, 1, 0)
    }
}

impl Default for Position {
    fn default() -> Self {
        Self::zero()
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub struct Loc {
    pub path: PathId,
    pub start: Position,
    pub end: Position,
}

impl Loc {
    pub fn point(path: PathId, pos: Position) -> Self {
        Self {
            path,
            start: pos,
            end: pos,
        }
    }

    pub fn span(path: PathId, start: Position, end: Position) -> Self {
        Self { path, start, end }
    }
}

#[derive(Debug, Default, Clone)]
pub struct PathInterner {
    paths: Vec<PathBuf>,
    index: HashMap<PathBuf, PathId>,
}

impl PathInterner {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn intern(&mut self, p: &Path) -> PathId {
        if let Some(id) = self.index.get(p) {
            return *id;
        }
        let id = PathId::new(u32::try_from(self.paths.len()).expect("path id overflow"));
        let owned = p.to_path_buf();
        self.paths.push(owned.clone());
        self.index.insert(owned, id);
        id
    }

    pub fn get(&self, id: PathId) -> Option<&Path> {
        self.paths.get(id.as_u32() as usize).map(PathBuf::as_path)
    }

    pub fn len(&self) -> usize {
        self.paths.len()
    }

    pub fn is_empty(&self) -> bool {
        self.paths.is_empty()
    }
}