code2graph 0.0.0-beta.17

Purpose-neutral code-graph extraction: source files → symbols, references, and cross-file edges. Tree-sitter based, no storage opinion.
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
113
114
115

// SPDX-License-Identifier: Apache-2.0

//! Custom serde implementations for [`SymbolId`].
//!
//! SCIP deliberately has no language or local-file coordinate. The lossless
//! versioned wire representation carries those coordinates explicitly while
//! retaining a parseable standard SCIP string.

use super::id::{SymbolId, SymbolIdWire};

impl serde::Serialize for SymbolId {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        self.to_wire().serialize(serializer)
    }
}

impl<'de> serde::Deserialize<'de> for SymbolId {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(serde::Deserialize)]
        #[serde(untagged)]
        enum Input {
            Legacy(String),
            Wire(SymbolIdWire),
        }
        match Input::deserialize(deserializer)? {
            Input::Legacy(s) => SymbolId::from_scip_string(&s).map_err(serde::de::Error::custom),
            Input::Wire(w) => SymbolId::try_from_wire(w).map_err(serde::de::Error::custom),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::symbol::{Descriptor, SymbolId};

    #[test]
    fn legacy_scip_string_remains_readable() {
        let id = SymbolId::global("rust", vec![Descriptor::Term("run".into())]);
        let legacy = serde_json::to_string(&id.to_scip_string()).unwrap();
        assert_eq!(
            serde_json::from_str::<SymbolId>(&legacy)
                .unwrap()
                .to_scip_string(),
            id.to_scip_string()
        );
    }

    #[test]
    fn versioned_wire_round_trips_global_and_local_identity() {
        let global = SymbolId::global("rust", vec![Descriptor::Term("run".into())]);
        let local = SymbolId::local("src/main.rs", "x0");

        for id in [global, local] {
            let json = serde_json::to_string(&id).unwrap();
            let restored: SymbolId = serde_json::from_str(&json).unwrap();
            assert_eq!(restored, id);
        }
    }

    #[test]
    fn versioned_wire_rejects_invalid_coordinate_combinations() {
        let cases = [
            (
                r#"{"version":1,"scip":"codegraph . . . run."}"#,
                "global SymbolId wire requires lang",
            ),
            (
                r#"{"version":1,"scip":"codegraph . . . run.","file":"src/main.rs"}"#,
                "global SymbolId wire requires lang",
            ),
            (
                r#"{"version":1,"scip":"codegraph . . . run.","lang":"rust","file":"src/main.rs"}"#,
                "global SymbolId wire requires lang",
            ),
            (
                r#"{"version":1,"scip":"local x0"}"#,
                "local SymbolId wire requires file",
            ),
            (
                r#"{"version":1,"scip":"local x0","lang":"rust"}"#,
                "local SymbolId wire requires file",
            ),
            (
                r#"{"version":1,"scip":"local x0","lang":"rust","file":"src/main.rs"}"#,
                "local SymbolId wire requires file",
            ),
        ];

        for (json, expected) in cases {
            let error = serde_json::from_str::<SymbolId>(json).unwrap_err();
            assert!(error.to_string().contains(expected), "{error}");
        }
    }

    #[test]
    fn unsupported_wire_version_is_rejected() {
        let error = serde_json::from_str::<SymbolId>(r#"{"version":2,"scip":"codegraph . run."}"#)
            .unwrap_err();
        assert!(
            error
                .to_string()
                .contains("unsupported SymbolId wire version")
        );
    }

    #[test]
    fn version_is_required_and_unknown_wire_fields_are_rejected() {
        for json in [
            r#"{"scip":"local x","file":"src/a.rs"}"#,
            r#"{"version":1,"scip":"local x","file":"src/a.rs","extra":0}"#,
        ] {
            assert!(serde_json::from_str::<SymbolId>(json).is_err(), "{json}");
        }
    }
}