codenexus 0.3.8

A queryable code knowledge graph tool built on LadybugDB and tree-sitter
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

// Copyright (c) 2026 Kirky.X. All rights reserved.
// SPDX-License-Identifier: MIT

//! Intermediate extraction records collected per file.

use crate::model::Language;

/// Information about an import/include statement extracted from source.
///
/// Captured for later resolution of cross-file references (Imports/Includes
/// edges, DDD §7.2).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ImportInfo {
    /// The source module or file being imported from
    /// (e.g. `"std::io"`, `"stdio.h"`, `"./utils"`).
    pub source_file: String,
    /// The specific names imported (empty for wildcard/star imports).
    pub imported_names: Vec<String>,
    /// The 1-based line number of the import statement.
    pub line: u32,
    /// B7: `true` when the statement is a re-export (Rust `pub use foo::bar;`,
    /// TypeScript `export { foo } from './mod'`). Re-exported symbols are
    /// treated as live entry points by dead-code analysis (the symbol is
    /// reachable from outside the current crate/module via the re-export).
    /// Default `false` for ordinary imports.
    pub is_reexport: bool,
}

impl Default for ImportInfo {
    /// B7 review (arch-review LOW-4): provides `Default` so future field
    /// additions don't force a shotgun-surgery update of every construction
    /// site. Existing callers still spell out all fields explicitly (Rule 24
    /// — business-scene coverage), but new fields can use `..Default::default()`.
    fn default() -> Self {
        Self {
            source_file: String::new(),
            imported_names: Vec::new(),
            line: 0,
            is_reexport: false,
        }
    }
}

/// Information about a function or method call extracted from source.
///
/// Captured for later resolution of Calls edges (DDD §7.2).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CallInfo {
    /// The qualified name of the calling function/method, if known.
    pub caller_qn: Option<String>,
    /// The name of the called function/method.
    pub callee_name: String,
    /// The 1-based line number of the call expression.
    pub line: u32,
    /// String representations of the call arguments (for data-flow analysis).
    pub args: Vec<String>,
}

/// Information about a variable assignment extracted from source.
///
/// Captured for later resolution of DataFlows/Reads/Writes edges
/// (BR-TRACE-002, BR-TRACE-003).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct AssignInfo {
    /// The name of the variable being assigned.
    pub target_name: String,
    /// The name of the source expression (variable or function call).
    pub source_name: String,
    /// The 1-based line number of the assignment.
    pub line: u32,
    /// Whether this assignment captures a function return value
    /// (BR-TRACE-002 return assignment).
    pub is_return_assign: bool,
}

/// Information about an extern/FFI declaration extracted from source.
///
/// Captured for later cross-language FFI resolution (ADD §7.4,
/// BR-TRACE-008).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ExternInfo {
    /// The foreign language being interfaced with.
    pub language: Language,
    /// The names of the extern symbols declared.
    pub names: Vec<String>,
    /// The 1-based line number of the declaration.
    pub line: u32,
    /// The signature of the extern declaration, if available.
    pub signature: Option<String>,
}

/// Information about a variable read within a function body.
///
/// Captured for later resolution of Reads edges (Function -> Variable,
/// BR-TRACE-005). `reader_qn` holds the name of the enclosing function/
/// method (resolved against the symbol table during resolution).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ReadInfo {
    /// The function/method that reads the variable (function name; the
    /// resolver looks it up in the symbol table to obtain its FQN).
    pub reader_qn: Option<String>,
    /// The name of the variable being read.
    pub var_name: String,
    /// The 1-based line number.
    pub line: u32,
}

/// Information about a variable write within a function body.
///
/// Captured for later resolution of Writes edges (Function -> Variable,
/// BR-TRACE-006). `writer_qn` holds the name of the enclosing function/
/// method (resolved against the symbol table during resolution).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct WriteInfo {
    /// The function/method that writes the variable (function name; the
    /// resolver looks it up in the symbol table to obtain its FQN).
    pub writer_qn: Option<String>,
    /// The name of the variable being written.
    pub var_name: String,
    /// The 1-based line number.
    pub line: u32,
}