code-moniker-core 0.7.1

Core symbol-graph types and per-language extractors for code-moniker.
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

use std::collections::HashMap;

use tree_sitter::Node;

use crate::core::moniker::Moniker;
use crate::lang::sdk::{DiscoveredDef, ResolvedRef, ResolvedRefDeduper, TypeExpr};

use super::defs::collect_defs;
use super::imports::{ImportedSymbol, collect_imports};
use super::refs::collect_refs;
use super::symbols::predeclare_types;

pub(super) type CallableTable = HashMap<(Moniker, Vec<u8>, usize), Vec<u8>>;
pub(super) type ReturnTypeTable = HashMap<(Moniker, Vec<u8>, usize), TypeExpr>;
pub(super) type FieldTypeTable = HashMap<(Moniker, Vec<u8>), TypeExpr>;
pub(super) type TypeParamTable = HashMap<Moniker, Vec<Vec<u8>>>;
pub(super) type TypeTable = HashMap<(Moniker, Vec<u8>), Moniker>;

pub(super) struct DiscoveredJavaFile {
	pub root: Moniker,
	pub defs: Vec<DiscoveredDef>,
	pub refs: Vec<ResolvedRef>,
}

pub(super) struct JavaDiscover<'src> {
	pub(super) root: Moniker,
	pub(super) source: &'src [u8],
	pub(super) deep: bool,
	pub(super) defs: Vec<DiscoveredDef>,
	pub(super) refs: Vec<ResolvedRef>,
	ref_deduper: ResolvedRefDeduper,
	pub(super) imports: Vec<ImportedSymbol>,
	pub(super) callables: CallableTable,
	pub(super) return_types: ReturnTypeTable,
	pub(super) field_types: FieldTypeTable,
	pub(super) type_table: TypeTable,
	pub(super) type_params: TypeParamTable,
}

impl<'src> JavaDiscover<'src> {
	pub fn run(
		root: Moniker,
		source: &'src [u8],
		deep: bool,
		root_node: Node<'_>,
	) -> DiscoveredJavaFile {
		let mut discover = Self {
			root: root.clone(),
			source,
			deep,
			defs: Vec::new(),
			refs: Vec::new(),
			ref_deduper: ResolvedRefDeduper::default(),
			imports: Vec::new(),
			callables: HashMap::new(),
			return_types: HashMap::new(),
			field_types: HashMap::new(),
			type_table: HashMap::new(),
			type_params: HashMap::new(),
		};
		collect_imports(&mut discover, root_node, &root);
		predeclare_types(&mut discover, root_node, &root);
		collect_defs(&mut discover, root_node, &root);
		super::lombok::emit_generated_members(&mut discover, root_node, &root);
		collect_refs(&mut discover, root_node, &root);
		DiscoveredJavaFile {
			root,
			defs: discover.defs,
			refs: discover.refs,
		}
	}

	pub(super) fn push_def(&mut self, def: DiscoveredDef) {
		if !self
			.defs
			.iter()
			.any(|existing| existing.moniker == def.moniker)
		{
			self.defs.push(def);
		}
	}

	pub(super) fn push_ref(&mut self, reference: ResolvedRef) {
		self.ref_deduper.push(&mut self.refs, reference);
	}
}