mirror of
https://github.com/colbymchenry/codegraph.git
synced 2026-09-19 07:34:57 +08:00
Colby Mchenry
8c047342cd
Apply upstream PR #1623 by danusha2345 (fix commit aa777063),
which also addresses #1616, to the current main base. Preserve the
upstream WASM and Rust implementations and regression coverage.
Index assigned locals, table members, static string keys and nested
callback tables as callable symbols, with calls owned by those symbols.
Keep dynamic keys unguessed. Add #1650 to the Unreleased changelog and
retain the existing re-index guidance without an extraction-version bump.
Verified on Linux x64 with Node 22.19.0:
- native kernel build, tsc, asset copy, executable CLI
- issue repro: 3 nodes / 2 edges -> 4 nodes / 4 edges
- EPR.PowerController::SyncHydroPower is indexed; its caller is client.lua
- syncHydroPower depth-2 impact reaches client.lua
- extraction/resolution/Lua parity: 844 tests passed (kernel expected)
- forced-WASM Lua/Luau extraction/resolution: 20 tests passed
Co-authored-by: Colby McHenry <colbymchenry@users.noreply.github.com>
973 lines
37 KiB
Rust
973 lines
37 KiB
Rust
//! Lua + Luau extraction — a faithful Rust port of the lua/luau paths of
|
||
//! `TreeSitterExtractor` (src/extraction/tree-sitter.ts) plus
|
||
//! languages/lua.ts and languages/luau.ts (36 lines extending lua).
|
||
//!
|
||
//! One walker, two dialects (ccpp precedent): the differences are exactly
|
||
//! four — luau's typeAliasTypes=['type_definition'], the `export `-slice
|
||
//! isExported hook, the return-type signature suffix, and the grammar handle.
|
||
//! The authoritative quirk list is docs/design/lua-luau-kernel-port-checklist.md.
|
||
//! Load-bearing oddities preserved on purpose: the require/visitNode-hook
|
||
//! ASYMMETRIES (top-level requires — including inside top-level if/for/while
|
||
//! blocks — mint import nodes, while the identical statement in a function
|
||
//! body emits `calls "require"`; a top-level `local x = foo()` initializer
|
||
//! emits NO calls ref while a top-level global `x = foo()` does), the BFS
|
||
//! string-win inside require args (`require(script:WaitForChild("Kid"))` →
|
||
//! import "Kid"; `require("a".."b")` → import "a"), raw-text callees verbatim
|
||
//! (colon forms `M:render` with `self` never stripped, brackets `t2[k2]`,
|
||
//! newline-glued chains byte-verbatim, the `(handler)` paren-conversion),
|
||
//! receiver-QN methods (`M.sub.deep::chained`, stack-QN nested globals like
|
||
//! `render::leakedGlobal`), variable nodes positioned at the IDENTIFIER with
|
||
//! positional value pairing, LuaDoc `---` keeping a leading `- ` and
|
||
//! `--!strict` joining docstring chains, the lua↔luau isExported wire
|
||
//! divergence (lua functions: flag ABSENT; luau functions: present-false;
|
||
//! methods: absent in both; variables: present-false in both), and duplicate
|
||
//! same-(kind,name,line) ids emitted twice. Positions in UTF-16 code units.
|
||
//! Files with parse errors defer to wasm (lua ~0%; luau 1.4–7.1% both-arm).
|
||
|
||
use crate::buffers::{
|
||
build_meta, edge_kind_index, node_kind_index, Arena, BoolFlags, EdgeRow, EmitOut, NodeRow,
|
||
RefRow, Tables, FLAG_IS_EXPORTED, FUNCTION_REF_CODE, NONE, NONE_STR, StrRef,
|
||
};
|
||
use crate::docstring::preceding_docstring;
|
||
use crate::ids;
|
||
use crate::textutil as util;
|
||
use std::collections::{HashSet, VecDeque};
|
||
use tree_sitter::{Node, Parser};
|
||
|
||
/// NAME_STOPLIST (function-ref.ts).
|
||
fn is_stoplisted(name: &str) -> bool {
|
||
matches!(
|
||
name,
|
||
"this" | "self" | "super" | "null" | "nil" | "true" | "false" | "undefined" | "new"
|
||
| "NULL" | "nullptr" | "None"
|
||
)
|
||
}
|
||
|
||
struct Scope {
|
||
row: u32,
|
||
kind: &'static str,
|
||
name: String,
|
||
}
|
||
|
||
struct Cand {
|
||
from: u32,
|
||
name: String,
|
||
line: u32,
|
||
column_byte: usize,
|
||
row: usize,
|
||
}
|
||
|
||
#[derive(Default)]
|
||
struct Extra<'a> {
|
||
docstring: Option<String>,
|
||
signature: Option<String>,
|
||
/// Some(_) sets the present bit (luau functions/type_aliases, variables
|
||
/// in both dialects); None leaves the pair absent (lua functions,
|
||
/// methods, imports).
|
||
is_exported: Option<bool>,
|
||
qualified_name_override: Option<String>,
|
||
_marker: std::marker::PhantomData<&'a ()>,
|
||
}
|
||
|
||
pub struct Walker<'t> {
|
||
src: &'t str,
|
||
file_path: &'t str,
|
||
is_luau: bool,
|
||
line_starts: Vec<usize>,
|
||
arena: Arena,
|
||
tables: Tables,
|
||
stack: Vec<Scope>,
|
||
node_ids: Vec<String>,
|
||
defined_fn_names: HashSet<String>,
|
||
imported_names: HashSet<String>,
|
||
fn_ref_cands: Vec<Cand>,
|
||
}
|
||
|
||
pub fn extract(file_path: &str, source: &str, language: &str) -> Result<EmitOut, String> {
|
||
let grammar = crate::langs::grammar_for(language).ok_or("no lua/luau grammar")?;
|
||
let t0 = std::time::Instant::now();
|
||
let mut parser = Parser::new();
|
||
parser
|
||
.set_language(&grammar)
|
||
.map_err(|e| format!("set_language({language}) failed: {e}"))?;
|
||
let tree = parser
|
||
.parse(source, None)
|
||
.ok_or_else(|| "parser returned null tree".to_string())?;
|
||
if tree.root_node().has_error() {
|
||
return Err("defer: parse tree contains errors — wasm recovery is canonical".to_string());
|
||
}
|
||
|
||
let mut w = Walker {
|
||
src: source,
|
||
file_path,
|
||
is_luau: language == "luau",
|
||
line_starts: util::line_starts(source),
|
||
arena: Arena::default(),
|
||
tables: Tables::default(),
|
||
stack: Vec::new(),
|
||
node_ids: Vec::new(),
|
||
defined_fn_names: HashSet::new(),
|
||
imported_names: HashSet::new(),
|
||
fn_ref_cands: Vec::new(),
|
||
};
|
||
|
||
// File node (tree-sitter.ts:508-521).
|
||
let line_count = source.bytes().filter(|b| *b == b'\n').count() as u32 + 1;
|
||
let base_name = file_path.rsplit(['/', '\\']).next().unwrap_or(file_path);
|
||
let mut flags = BoolFlags::default();
|
||
flags.set(FLAG_IS_EXPORTED, false);
|
||
let file_id = w.arena.put(&ids::file_node_id(file_path));
|
||
let name_ref = w.arena.put(base_name);
|
||
let qn_ref = w.arena.put(file_path);
|
||
w.tables.push_node(&NodeRow {
|
||
kind: node_kind_index("file").unwrap(),
|
||
visibility: 0,
|
||
flags,
|
||
start_line: 1,
|
||
end_line: line_count,
|
||
start_column: 0,
|
||
end_column: 0,
|
||
name: name_ref,
|
||
qualified_name: qn_ref,
|
||
id: file_id,
|
||
docstring: NONE_STR,
|
||
signature: NONE_STR,
|
||
decorators: NONE_STR,
|
||
type_parameters: NONE_STR,
|
||
return_type: NONE_STR,
|
||
extra_json: NONE_STR,
|
||
});
|
||
w.node_ids.push(ids::file_node_id(file_path));
|
||
w.stack.push(Scope { row: 0, kind: "file", name: base_name.to_string() });
|
||
|
||
// No packageTypes → no namespace node. Value-refs are language-gated off.
|
||
w.visit(tree.root_node());
|
||
w.flush_fn_ref_candidates();
|
||
w.stack.pop();
|
||
|
||
let duration_ms = t0.elapsed().as_secs_f64() * 1000.0;
|
||
let meta = build_meta(&w.tables, w.arena.len(), NONE_STR, duration_ms);
|
||
Ok(EmitOut {
|
||
meta,
|
||
nodes: w.tables.nodes,
|
||
edges: w.tables.edges,
|
||
refs: w.tables.refs,
|
||
arena: w.arena.into_vec(),
|
||
})
|
||
}
|
||
|
||
impl<'t> Walker<'t> {
|
||
fn text(&self, node: Node) -> &'t str {
|
||
&self.src[node.byte_range()]
|
||
}
|
||
fn line_of(&self, node: Node) -> u32 {
|
||
node.start_position().row as u32 + 1
|
||
}
|
||
fn col_of(&self, node: Node) -> u32 {
|
||
util::col16(self.src, &self.line_starts, node.start_position().row, node.start_byte())
|
||
}
|
||
fn end_col_of(&self, node: Node) -> u32 {
|
||
util::col16(self.src, &self.line_starts, node.end_position().row, node.end_byte())
|
||
}
|
||
fn top_row(&self) -> u32 {
|
||
self.stack.last().map(|s| s.row).unwrap_or(0)
|
||
}
|
||
|
||
fn push_ref_at(&mut self, from_row: u32, name: &str, kind: &str, node: Node) {
|
||
let name_ref = self.arena.put(name);
|
||
self.tables.push_ref(&RefRow {
|
||
from_idx: from_row,
|
||
kind: edge_kind_index(kind).unwrap(),
|
||
line: self.line_of(node),
|
||
column: self.col_of(node),
|
||
reference_name: name_ref,
|
||
candidates: NONE_STR,
|
||
from_id_str: NONE_STR,
|
||
});
|
||
// flushFnRefCandidates' importedNames gate (tree-sitter.ts:661-675):
|
||
// dotted lua module paths contribute their LAST segment; simple names
|
||
// (Roblox leaves) pass whole.
|
||
if kind == "imports" {
|
||
if util::simple_name().is_match(name) {
|
||
self.imported_names.insert(name.to_string());
|
||
} else if let Some(c) = util::qualified_import().captures(name) {
|
||
self.imported_names.insert(c[1].to_string());
|
||
}
|
||
}
|
||
}
|
||
|
||
// --- createNode (tree-sitter.ts:1308) ---------------------------------
|
||
|
||
fn create_node(&mut self, kind: &'static str, name: &str, node: Node<'t>, extra: Extra) -> Option<u32> {
|
||
if name.is_empty() {
|
||
return None;
|
||
}
|
||
let start_line = self.line_of(node);
|
||
let id = ids::node_id(self.file_path, kind, name, start_line);
|
||
|
||
// buildQualifiedName (1447-1460) — non-file stack NAMES joined `::`;
|
||
// the receiver override (extractMethod:1790-1792) replaces it whole.
|
||
let qualified = match &extra.qualified_name_override {
|
||
Some(qn) => qn.clone(),
|
||
None => {
|
||
let mut parts: Vec<&str> = Vec::new();
|
||
for s in &self.stack {
|
||
if s.kind != "file" {
|
||
parts.push(&s.name);
|
||
}
|
||
}
|
||
let mut qn = parts.join("::");
|
||
if !qn.is_empty() {
|
||
qn.push_str("::");
|
||
}
|
||
qn.push_str(name);
|
||
qn
|
||
}
|
||
};
|
||
|
||
let name_ref = self.arena.put(name);
|
||
let qn_ref = self.arena.put(&qualified);
|
||
let id_ref = self.arena.put(&id);
|
||
let doc_ref = opt_str(&mut self.arena, extra.docstring.as_deref());
|
||
let sig_ref = opt_str(&mut self.arena, extra.signature.as_deref());
|
||
let mut flags = BoolFlags::default();
|
||
if let Some(v) = extra.is_exported {
|
||
flags.set(FLAG_IS_EXPORTED, v);
|
||
}
|
||
let row = self.tables.push_node(&NodeRow {
|
||
kind: node_kind_index(kind).unwrap(),
|
||
visibility: 0,
|
||
flags,
|
||
start_line,
|
||
end_line: node.end_position().row as u32 + 1, // no resolveBody
|
||
start_column: self.col_of(node),
|
||
end_column: self.end_col_of(node),
|
||
name: name_ref,
|
||
qualified_name: qn_ref,
|
||
id: id_ref,
|
||
docstring: doc_ref,
|
||
signature: sig_ref,
|
||
decorators: NONE_STR,
|
||
type_parameters: NONE_STR,
|
||
return_type: NONE_STR,
|
||
extra_json: NONE_STR,
|
||
});
|
||
self.node_ids.push(id);
|
||
if kind == "function" || kind == "method" {
|
||
self.defined_fn_names.insert(name.to_string());
|
||
}
|
||
|
||
let parent_row = self.top_row();
|
||
self.tables.push_edge(&EdgeRow {
|
||
source_idx: parent_row,
|
||
target_idx: row,
|
||
kind: edge_kind_index("contains").unwrap(),
|
||
provenance: 0,
|
||
line: NONE,
|
||
column: NONE,
|
||
metadata_json: NONE_STR,
|
||
source_id_str: NONE_STR,
|
||
target_id_str: NONE_STR,
|
||
});
|
||
|
||
Some(row)
|
||
}
|
||
|
||
// --- lua.ts helper transcriptions -------------------------------------
|
||
|
||
/// findDescendant (lua.ts:9-17) — breadth-first over namedChildren.
|
||
fn find_descendant(&self, node: Node<'t>, kind: &str) -> Option<Node<'t>> {
|
||
let mut queue: VecDeque<Node<'t>> = VecDeque::new();
|
||
let mut cursor = node.walk();
|
||
for c in node.named_children(&mut cursor) {
|
||
queue.push_back(c);
|
||
}
|
||
while let Some(n) = queue.pop_front() {
|
||
if n.kind() == kind {
|
||
return Some(n);
|
||
}
|
||
let mut cur = n.walk();
|
||
for c in n.named_children(&mut cur) {
|
||
queue.push_back(c);
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
/// requireModule (lua.ts:28-60).
|
||
fn require_module(&self, call: Node<'t>) -> Option<String> {
|
||
let name = call.child_by_field_name("name")?;
|
||
if name.kind() != "identifier" || self.text(name) != "require" {
|
||
return None;
|
||
}
|
||
let args = call.child_by_field_name("arguments")?;
|
||
|
||
// String win: first string_content descendant, BFS order.
|
||
if let Some(content) = self.find_descendant(args, "string_content") {
|
||
let t = self.text(content).trim();
|
||
return if t.is_empty() { None } else { Some(t.to_string()) };
|
||
}
|
||
// Fallback: a string node with no content child — strip [[ ]] / quotes.
|
||
if let Some(s) = self.find_descendant(args, "string") {
|
||
let mut t = self.text(s).trim();
|
||
t = t.strip_prefix("[[").unwrap_or(t);
|
||
t = t.strip_suffix("]]").unwrap_or(t);
|
||
t = t.strip_prefix(['"', '\'']).unwrap_or(t);
|
||
t = t.strip_suffix(['"', '\'']).unwrap_or(t);
|
||
if !t.is_empty() {
|
||
return Some(t.to_string());
|
||
}
|
||
}
|
||
// Roblox instance path: trailing field/method segment.
|
||
let idx = self
|
||
.find_descendant(args, "dot_index_expression")
|
||
.or_else(|| self.find_descendant(args, "method_index_expression"));
|
||
if let Some(idx) = idx {
|
||
if let Some(field) = idx
|
||
.child_by_field_name("field")
|
||
.or_else(|| idx.child_by_field_name("method"))
|
||
{
|
||
let t = self.text(field).trim();
|
||
return if t.is_empty() { None } else { Some(t.to_string()) };
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
/// The hook's `emit` (lua.ts:108-126): import node at the CALL node +
|
||
/// imports ref from the stack top.
|
||
fn emit_require(&mut self, call: Node<'t>, module: &str) {
|
||
let (sig, _) = util::slice_utf16(self.text(call).trim(), 100);
|
||
let imp = self.create_node(
|
||
"import",
|
||
module,
|
||
call,
|
||
Extra { signature: Some(sig), ..Default::default() },
|
||
);
|
||
if imp.is_some() && !self.stack.is_empty() {
|
||
let parent_row = self.top_row();
|
||
self.push_ref_at(parent_row, module, "imports", call);
|
||
}
|
||
}
|
||
|
||
/// getReceiverType (lua.ts:92-99).
|
||
fn receiver_type(&self, node: Node<'t>) -> Option<&'t str> {
|
||
let name = node.child_by_field_name("name")?;
|
||
if name.kind() == "dot_index_expression" || name.kind() == "method_index_expression" {
|
||
return name.child_by_field_name("table").map(|t| self.text(t));
|
||
}
|
||
None
|
||
}
|
||
|
||
/// extractName (tree-sitter.ts:98-192) — the lua-reachable branches.
|
||
fn extract_name(&self, node: Node<'t>) -> String {
|
||
if let Some(name_node) = node.child_by_field_name("name") {
|
||
// Lua: dot/method index → the trailing field/method segment.
|
||
if name_node.kind() == "dot_index_expression" {
|
||
if let Some(f) = name_node.child_by_field_name("field") {
|
||
return self.text(f).to_string();
|
||
}
|
||
}
|
||
if name_node.kind() == "method_index_expression" {
|
||
if let Some(m) = name_node.child_by_field_name("method") {
|
||
return self.text(m).to_string();
|
||
}
|
||
}
|
||
return self.text(name_node).to_string();
|
||
}
|
||
// Fallback: first identifier-ish named child.
|
||
let mut cursor = node.walk();
|
||
for c in node.named_children(&mut cursor) {
|
||
if matches!(c.kind(), "identifier" | "type_identifier" | "simple_identifier" | "constant") {
|
||
return self.text(c).to_string();
|
||
}
|
||
}
|
||
"<anonymous>".to_string()
|
||
}
|
||
|
||
/// getSignature — lua (lua.ts:83-86) / luau (luau.ts:26-35).
|
||
fn signature_of(&self, node: Node<'t>) -> Option<String> {
|
||
let params = node.child_by_field_name("parameters")?;
|
||
let mut sig = self.text(params).to_string();
|
||
if self.is_luau {
|
||
// Return type = the named child AFTER `parameters` (found by
|
||
// startIndex match), unless it's the block.
|
||
let mut cursor = node.walk();
|
||
let kids: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
|
||
if let Some(idx) = kids.iter().position(|k| k.start_byte() == params.start_byte()) {
|
||
if let Some(ret) = kids.get(idx + 1) {
|
||
if ret.kind() != "block" {
|
||
sig.push_str(": ");
|
||
sig.push_str(self.text(*ret));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Some(sig)
|
||
}
|
||
|
||
/// isExported (luau.ts:23) — the raw 7-unit slice is an ASCII prefix test.
|
||
fn is_exported_of(&self, node: Node<'t>) -> Option<bool> {
|
||
if self.is_luau {
|
||
Some(self.text(node).starts_with("export "))
|
||
} else {
|
||
None
|
||
}
|
||
}
|
||
|
||
// --- the main walk (visitNode, tree-sitter.ts:936-1303) ---------------
|
||
|
||
fn visit(&mut self, node: Node<'t>) {
|
||
stack_guard!();
|
||
let kind = node.kind();
|
||
|
||
// The visitNode hook (lua.ts:105-151) runs FIRST.
|
||
if kind == "function_call" {
|
||
if let Some(module) = self.require_module(node) {
|
||
self.emit_require(node, &module);
|
||
// Consumed → scanFnRefSubtree (tree-sitter.ts:951).
|
||
self.scan_fn_ref_subtree(node, 0);
|
||
return;
|
||
}
|
||
// falls through — extractCall claims it below
|
||
} else if kind == "variable_declaration" {
|
||
// `local x = require(...)` — dig requires out of the initializer
|
||
// the variable branch will skip. Always falls through.
|
||
let mut cursor = node.walk();
|
||
let assign = node.named_children(&mut cursor).find(|c| c.kind() == "assignment_statement");
|
||
if let Some(assign) = assign {
|
||
let mut ac = assign.walk();
|
||
let expr_list = assign.named_children(&mut ac).find(|c| c.kind() == "expression_list");
|
||
if let Some(expr_list) = expr_list {
|
||
let mut ec = expr_list.walk();
|
||
let vals: Vec<Node<'t>> = expr_list.named_children(&mut ec).collect();
|
||
for val in vals {
|
||
if val.kind() == "function_call" {
|
||
if let Some(module) = self.require_module(val) {
|
||
self.emit_require(val, &module);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// maybeCaptureFnRefs (tree-sitter.ts:990).
|
||
self.maybe_capture_fn_refs(node);
|
||
|
||
// The dispatch ladder — lua/luau rows only.
|
||
if kind == "function_declaration" {
|
||
// isInsideClassLikeNode is always false (no class-like kinds).
|
||
self.extract_function(node);
|
||
return; // skipChildren — the body walk handles children
|
||
}
|
||
if self.is_luau && kind == "type_definition" {
|
||
let skip = self.extract_type_alias(node);
|
||
if skip {
|
||
return;
|
||
}
|
||
// plain path returns false → children re-visited (the
|
||
// typeof(require(...)) alias+import pair rides this).
|
||
} else if matches!(kind, "variable_declaration" | "assignment_statement") {
|
||
self.extract_variable(node);
|
||
// Initializer subtrees are never walked — candidates only.
|
||
self.scan_fn_ref_subtree(node, 0);
|
||
return; // skipChildren
|
||
} else if kind == "function_call" {
|
||
self.extract_call(node);
|
||
// no skipChildren — nested/inner calls each get their own ref
|
||
}
|
||
|
||
let mut cursor = node.walk();
|
||
let children: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
|
||
for child in children {
|
||
self.visit(child);
|
||
}
|
||
}
|
||
|
||
// --- extractFunction / extractMethod (1517 / 1737) --------------------
|
||
|
||
fn extract_function(&mut self, node: Node<'t>) {
|
||
stack_guard!();
|
||
// :1522 receiver short-circuit IS the method routing.
|
||
if let Some(receiver) = self.receiver_type(node) {
|
||
let receiver = receiver.to_string();
|
||
self.extract_method(node, receiver);
|
||
return;
|
||
}
|
||
let name = self.extract_name(node);
|
||
if name == "<anonymous>" {
|
||
// Unreachable for function_declaration (grammar requires a name)
|
||
// but preserved: body walked with nothing pushed.
|
||
if let Some(body) = node.child_by_field_name("body") {
|
||
self.visit_body(body);
|
||
}
|
||
return;
|
||
}
|
||
let docstring = preceding_docstring(node, self.src);
|
||
let signature = self.signature_of(node);
|
||
let is_exported = self.is_exported_of(node); // lua None / luau Some(false)
|
||
let fn_row = self.create_node(
|
||
"function",
|
||
&name,
|
||
node,
|
||
Extra { docstring, signature, is_exported, ..Default::default() },
|
||
);
|
||
let Some(row) = fn_row else { return };
|
||
// extractTypeAnnotations / extractDecoratorsFor: structurally zero
|
||
// output for lua/luau (gates + no decorator kinds in scan positions).
|
||
self.stack.push(Scope { row, kind: "function", name });
|
||
if let Some(body) = node.child_by_field_name("body") {
|
||
self.visit_body(body);
|
||
}
|
||
self.stack.pop();
|
||
}
|
||
|
||
fn extract_method(&mut self, node: Node<'t>, receiver: String) {
|
||
stack_guard!();
|
||
let name = self.extract_name(node);
|
||
let docstring = preceding_docstring(node, self.src);
|
||
let signature = self.signature_of(node);
|
||
// extractMethod passes NO isExported — absent for BOTH dialects.
|
||
// QN override (:1790-1792): `receiver::name` verbatim (namespacePrefix
|
||
// is empty outside C++).
|
||
let qn = format!("{receiver}::{name}");
|
||
let method_row = self.create_node(
|
||
"method",
|
||
&name,
|
||
node,
|
||
Extra {
|
||
docstring,
|
||
signature,
|
||
qualified_name_override: Some(qn),
|
||
..Default::default()
|
||
},
|
||
);
|
||
let Some(row) = method_row else { return };
|
||
// Owner-contains (:1799-1813) never fires: lua mints no
|
||
// struct/class/enum/trait nodes for a receiver name to match.
|
||
self.stack.push(Scope { row, kind: "method", name });
|
||
if let Some(body) = node.child_by_field_name("body") {
|
||
self.visit_body(body);
|
||
}
|
||
self.stack.pop();
|
||
}
|
||
|
||
// --- extractVariable — the lua/luau branch (2538-2549, 2789-2805) -----
|
||
|
||
fn extract_variable(&mut self, node: Node<'t>) {
|
||
// isConst absent → kind is ALWAYS `variable`; docstring from the
|
||
// DECLARATION node; isExported = hook ?? false → false for BOTH
|
||
// dialects (luau's slice sees `local …`).
|
||
let docstring = preceding_docstring(node, self.src);
|
||
let is_exported = self.is_exported_of(node).unwrap_or(false);
|
||
|
||
let mut cursor = node.walk();
|
||
let assign = node
|
||
.named_children(&mut cursor)
|
||
.find(|c| c.kind() == "assignment_statement")
|
||
.unwrap_or(node);
|
||
let mut ac = assign.walk();
|
||
let var_list = assign.named_children(&mut ac).find(|c| c.kind() == "variable_list");
|
||
let mut ec = assign.walk();
|
||
let expr_list = assign.named_children(&mut ec).find(|c| c.kind() == "expression_list");
|
||
let values: Vec<Node<'t>> = match expr_list {
|
||
Some(el) => {
|
||
let mut c = el.walk();
|
||
el.named_children(&mut c).collect()
|
||
}
|
||
None => Vec::new(),
|
||
};
|
||
let targets: Vec<Node<'t>> = match var_list {
|
||
Some(vl) => {
|
||
let mut c = vl.walk();
|
||
vl.named_children(&mut c).collect()
|
||
}
|
||
None => Vec::new(),
|
||
};
|
||
for (i, name_node) in targets.iter().enumerate() {
|
||
let Some((name, receiver, full_name)) = self.lua_assignment_target(*name_node) else {
|
||
continue;
|
||
};
|
||
let value = values.get(i).copied();
|
||
if let Some(value) = value {
|
||
if value.kind() == "function_definition" {
|
||
self.extract_lua_function_value(
|
||
value,
|
||
name,
|
||
receiver,
|
||
docstring.clone(),
|
||
);
|
||
continue;
|
||
}
|
||
if value.kind() == "table_constructor" {
|
||
self.extract_lua_table_functions(value, full_name);
|
||
}
|
||
}
|
||
// Dotted assignments update table members, not standalone vars.
|
||
if receiver.is_some() || node.kind() == "assignment_statement" {
|
||
continue;
|
||
}
|
||
// Positional value pairing; a missing value → NO signature key.
|
||
let signature = value.map(|v| util::init_signature(self.text(v)));
|
||
self.create_node(
|
||
"variable",
|
||
&name,
|
||
*name_node, // positioned at the IDENTIFIER
|
||
Extra {
|
||
docstring: docstring.clone(),
|
||
signature,
|
||
is_exported: Some(is_exported),
|
||
..Default::default()
|
||
},
|
||
);
|
||
}
|
||
}
|
||
|
||
fn lua_assignment_target(&self, node: Node<'t>) -> Option<(String, Option<String>, String)> {
|
||
if node.kind() == "identifier" {
|
||
let name = self.text(node).trim().to_string();
|
||
if name.is_empty() {
|
||
return None;
|
||
}
|
||
return Some((name.clone(), None, name));
|
||
}
|
||
if !matches!(
|
||
node.kind(),
|
||
"dot_index_expression" | "method_index_expression" | "bracket_index_expression"
|
||
) {
|
||
return None;
|
||
}
|
||
let table = node.child_by_field_name("table")?;
|
||
let field = node
|
||
.child_by_field_name("field")
|
||
.or_else(|| node.child_by_field_name("method"))?;
|
||
let receiver = self.text(table).trim().to_string();
|
||
let name = self.lua_static_field_name(field, node.kind() == "bracket_index_expression");
|
||
if receiver.is_empty() || name.is_empty() {
|
||
return None;
|
||
}
|
||
let full_name = format!("{receiver}.{name}");
|
||
Some((name, Some(receiver), full_name))
|
||
}
|
||
|
||
fn lua_static_field_name(&self, node: Node<'t>, bracketed: bool) -> String {
|
||
if node.kind() == "identifier" {
|
||
return if bracketed {
|
||
String::new()
|
||
} else {
|
||
self.text(node).trim().to_string()
|
||
};
|
||
}
|
||
if node.kind() == "string" {
|
||
let mut cursor = node.walk();
|
||
for child in node.named_children(&mut cursor) {
|
||
if child.kind() == "string_content" {
|
||
return self.text(child).trim().to_string();
|
||
}
|
||
}
|
||
}
|
||
String::new()
|
||
}
|
||
|
||
fn extract_lua_function_value(
|
||
&mut self,
|
||
node: Node<'t>,
|
||
name: String,
|
||
receiver: Option<String>,
|
||
docstring: Option<String>,
|
||
) {
|
||
let signature = self.signature_of(node);
|
||
let (kind, qualified_name_override, is_exported) = match receiver {
|
||
Some(receiver) => (
|
||
"method",
|
||
Some(format!("{receiver}::{name}")),
|
||
None,
|
||
),
|
||
None => ("function", None, self.is_exported_of(node)),
|
||
};
|
||
let row = self.create_node(
|
||
kind,
|
||
&name,
|
||
node,
|
||
Extra {
|
||
docstring,
|
||
signature,
|
||
qualified_name_override,
|
||
is_exported,
|
||
..Default::default()
|
||
},
|
||
);
|
||
let Some(row) = row else { return };
|
||
self.stack.push(Scope { row, kind, name });
|
||
if let Some(body) = node.child_by_field_name("body") {
|
||
self.visit_body(body);
|
||
}
|
||
self.stack.pop();
|
||
}
|
||
|
||
fn extract_lua_table_functions(&mut self, table: Node<'t>, receiver: String) {
|
||
let mut cursor = table.walk();
|
||
let fields: Vec<Node<'t>> = table.named_children(&mut cursor).collect();
|
||
for field in fields {
|
||
if field.kind() != "field" {
|
||
continue;
|
||
}
|
||
let Some(name_node) = field.child_by_field_name("name") else { continue };
|
||
let Some(value) = field.child_by_field_name("value") else { continue };
|
||
let bracketed = self.text(field).trim_start().starts_with('[');
|
||
let name = self.lua_static_field_name(name_node, bracketed);
|
||
if name.is_empty() {
|
||
continue;
|
||
}
|
||
if value.kind() == "function_definition" {
|
||
self.extract_lua_function_value(value, name, Some(receiver.clone()), None);
|
||
} else if value.kind() == "table_constructor" {
|
||
self.extract_lua_table_functions(value, format!("{receiver}.{name}"));
|
||
}
|
||
}
|
||
}
|
||
|
||
// --- extractTypeAlias (2890; plain path 2967-2991) — luau only --------
|
||
|
||
/// Returns skipChildren (always false on the plain path).
|
||
fn extract_type_alias(&mut self, node: Node<'t>) -> bool {
|
||
let name = self.extract_name(node); // generic_type name → verbatim text
|
||
if name == "<anonymous>" {
|
||
return false;
|
||
}
|
||
let docstring = preceding_docstring(node, self.src);
|
||
let is_exported = self.is_exported_of(node); // Some(true) for `export type`
|
||
self.create_node(
|
||
"type_alias",
|
||
&name,
|
||
node,
|
||
Extra { docstring, is_exported, ..Default::default() },
|
||
);
|
||
// TYPE_ANNOTATION_LANGUAGES excludes luau → no alias-value refs.
|
||
false // children re-visited by the ladder
|
||
}
|
||
|
||
// --- extractCall (3684; generic tail 4313, 4518-4532, 4572-4580) ------
|
||
|
||
fn extract_call(&mut self, node: Node<'t>) {
|
||
if self.stack.is_empty() {
|
||
return;
|
||
}
|
||
let caller_row = self.top_row();
|
||
// The `function` field is NULL in this grammar → namedChild(0) (the
|
||
// `name:` child). Member branch never fires (dot/method_index aren't
|
||
// in its type list) → raw source text, then the paren-conversion.
|
||
let func = node
|
||
.child_by_field_name("function")
|
||
.or_else(|| node.named_child(0));
|
||
let Some(func) = func else { return };
|
||
let mut callee: &str = self.text(func);
|
||
if let Some(caps) = util::paren_conversion().captures(callee) {
|
||
if let Some(inner) = caps.get(1) {
|
||
callee = &callee[inner.range()];
|
||
}
|
||
}
|
||
if callee.is_empty() {
|
||
return;
|
||
}
|
||
let callee = callee.to_string();
|
||
self.push_ref_at(caller_row, &callee, "calls", node);
|
||
}
|
||
|
||
// --- visitFunctionBody (5129-5286) — the hook-free body walk ----------
|
||
|
||
fn visit_body(&mut self, node: Node<'t>) {
|
||
stack_guard!();
|
||
// maybeCaptureFnRefs (5137) fires in the body walker too.
|
||
self.maybe_capture_fn_refs(node);
|
||
|
||
let kind = node.kind();
|
||
if kind == "function_call" {
|
||
// The hook NEVER runs here — a body-level require emits
|
||
// `calls "require"` (the neovim lazy-loading idiom).
|
||
self.extract_call(node);
|
||
// falls through to recursion — chains emit every link
|
||
} else if kind == "function_declaration" {
|
||
// Nested NAMED functions (5245-5250): extractFunction walks the
|
||
// nested body itself, so return. extractName is never
|
||
// `<anonymous>` for function_declaration.
|
||
self.extract_function(node);
|
||
return;
|
||
}
|
||
// variable_declaration / type_definition have NO branch here → plain
|
||
// recursion: body-local initializers ARE walked (calls emit), no
|
||
// variable/type_alias nodes minted.
|
||
|
||
let mut cursor = node.walk();
|
||
let children: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
|
||
for child in children {
|
||
self.visit_body(child);
|
||
}
|
||
}
|
||
|
||
// --- function-as-value capture (#756) — LUA_SPEC ----------------------
|
||
|
||
fn maybe_capture_fn_refs(&mut self, node: Node<'t>) {
|
||
// LUA_SPEC dispatch: arguments → args; assignment_statement → rhs
|
||
// (no field — last named child; param-storage skip via namedChild(0));
|
||
// field → value (field 'value', last-named-child fallback).
|
||
let mode: &str = match node.kind() {
|
||
"arguments" => "args",
|
||
"assignment_statement" => "rhs",
|
||
"field" => "value",
|
||
_ => return,
|
||
};
|
||
if self.stack.is_empty() {
|
||
return;
|
||
}
|
||
let from = self.top_row();
|
||
|
||
let mut values: Vec<Node<'t>> = Vec::new();
|
||
match mode {
|
||
"args" => {
|
||
let mut cursor = node.walk();
|
||
for c in node.named_children(&mut cursor) {
|
||
values.push(c);
|
||
}
|
||
}
|
||
"rhs" => {
|
||
// No `field` in the rule → RHS = LAST named child (the
|
||
// expression_list). Param-storage skip: lhs =
|
||
// left/lhs/target field ?? namedChild(0) when ≥2 children;
|
||
// its trailing identifier vs the whole RHS text.
|
||
let count = node.named_child_count();
|
||
let rhs = if count > 0 { node.named_child(count - 1) } else { None };
|
||
if let Some(rhs) = rhs {
|
||
let lhs = node
|
||
.child_by_field_name("left")
|
||
.or_else(|| node.child_by_field_name("lhs"))
|
||
.or_else(|| node.child_by_field_name("target"))
|
||
.or_else(|| if count >= 2 { node.named_child(0) } else { None });
|
||
let lhs_text = lhs.map(|l| self.text(l)).unwrap_or("");
|
||
let lhs_last = util::lhs_last_name()
|
||
.captures(lhs_text)
|
||
.and_then(|c| c.get(1))
|
||
.map(|m| m.as_str());
|
||
if !(lhs_last.is_some() && lhs_last == Some(self.text(rhs).trim())) {
|
||
values.push(rhs);
|
||
}
|
||
}
|
||
}
|
||
_ => {
|
||
// value — the `value` field (keyed AND positional table
|
||
// fields carry it), falling back to the last named child.
|
||
let v = node.child_by_field_name("value").or_else(|| {
|
||
let count = node.named_child_count();
|
||
if count > 0 { node.named_child(count - 1) } else { None }
|
||
});
|
||
if let Some(v) = v {
|
||
values.push(v);
|
||
}
|
||
}
|
||
}
|
||
|
||
for v in values {
|
||
self.normalize_fn_ref_value(v, from, 0);
|
||
}
|
||
}
|
||
|
||
/// normalizeValue with LUA_SPEC's one transparent layer (expression_list
|
||
/// fans out to named children).
|
||
fn normalize_fn_ref_value(&mut self, v: Node<'t>, from: u32, depth: u32) {
|
||
stack_guard!();
|
||
if depth > 4 {
|
||
return;
|
||
}
|
||
match v.kind() {
|
||
"identifier" => {
|
||
let name = self.text(v).to_string();
|
||
if name.is_empty() || is_stoplisted(&name) {
|
||
return;
|
||
}
|
||
let p = v.start_position();
|
||
self.fn_ref_cands.push(Cand {
|
||
from,
|
||
name,
|
||
line: p.row as u32 + 1,
|
||
column_byte: v.start_byte(),
|
||
row: p.row,
|
||
});
|
||
}
|
||
"expression_list" => {
|
||
let mut cursor = v.walk();
|
||
let kids: Vec<Node<'t>> = v.named_children(&mut cursor).collect();
|
||
for c in kids {
|
||
self.normalize_fn_ref_value(c, from, depth + 1);
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
fn scan_fn_ref_subtree(&mut self, node: Node<'t>, depth: u32) {
|
||
stack_guard!();
|
||
if depth > 12 {
|
||
return;
|
||
}
|
||
// Halt at nested function definitions (their bodies are walked — and
|
||
// attributed — by extractFunction). Lua function_definition values are
|
||
// now extracted from their assignment target and must stop this scan too.
|
||
if depth > 0
|
||
&& matches!(
|
||
node.kind(),
|
||
"function_declaration" | "function_definition" | "arrow_function" | "function_expression"
|
||
| "lambda_literal" | "lambda_expression"
|
||
)
|
||
{
|
||
return;
|
||
}
|
||
self.maybe_capture_fn_refs(node);
|
||
let mut cursor = node.walk();
|
||
let children: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
|
||
for c in children {
|
||
self.scan_fn_ref_subtree(c, depth + 1);
|
||
}
|
||
}
|
||
|
||
fn flush_fn_ref_candidates(&mut self) {
|
||
let cands = std::mem::take(&mut self.fn_ref_cands);
|
||
if cands.is_empty() || util::is_generated_file(self.file_path) {
|
||
return;
|
||
}
|
||
let mut seen: HashSet<(String, String)> = HashSet::new();
|
||
for c in cands {
|
||
// Gate: same-file function/method names ∪ imported names (lua
|
||
// candidates are always bare identifiers — no `this.`/`::`).
|
||
if !c.name.starts_with("this.")
|
||
&& !c.name.contains("::")
|
||
&& !self.defined_fn_names.contains(&c.name)
|
||
&& !self.imported_names.contains(&c.name)
|
||
{
|
||
continue;
|
||
}
|
||
if !seen.insert((self.node_ids[c.from as usize].clone(), c.name.clone())) {
|
||
continue;
|
||
}
|
||
let column = util::col16(self.src, &self.line_starts, c.row, c.column_byte);
|
||
let name_ref = self.arena.put(&c.name);
|
||
self.tables.push_ref(&RefRow {
|
||
from_idx: c.from,
|
||
kind: FUNCTION_REF_CODE,
|
||
line: c.line,
|
||
column,
|
||
reference_name: name_ref,
|
||
candidates: NONE_STR,
|
||
from_id_str: NONE_STR,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
fn opt_str(arena: &mut Arena, s: Option<&str>) -> StrRef {
|
||
match s {
|
||
Some(s) => arena.put(s),
|
||
None => NONE_STR,
|
||
}
|
||
}
|