tiny.smg.scan.script

1pub const script = @import("script.zig");

1const std = @import("std");23const smg = @import("../root.zig");4const graph_mod = smg.graph;5const lines_mod = smg.lines;6const model = smg.model;7const scan_root = smg.scan;8const text = smg.text;9const tree = smg.tree;1011const core = scan_root.core;12const metrics = scan_root.scan_metrics;13const scan_files = scan_root.scan_files;1415const CallTarget = core.CallTarget;16const SourceLines = lines_mod.SourceLines;17const Stats = core.Stats;1819const braceDelta = metrics.braceDelta;20const identByte = metrics.identByte;21const javascriptFunctionMetadata = metrics.javascriptFunctionMetadata;22const scriptSpanMetadata = metrics.scriptSpanMetadata;23const textFunctionMetadata = metrics.textFunctionMetadata;24const textSpanMetadata = metrics.textSpanMetadata;2526const ScriptFunctionScope = struct {27    name: []const u8,28    start_line: i64,29    start_depth: i64,30    class_name: ?[]const u8 = null,31};3233const ScriptArrowSkipKind = enum {34    brace,35    paren,36};3738const ScriptArrowSkip = struct {39    kind: ScriptArrowSkipKind,40    brace_depth: i64,41    paren_depth: i64,42};4344const ScriptScanContext = struct {45    allocator: std.mem.Allocator,46    scratch: std.mem.Allocator,47    graph: *graph_mod.Graph,48    module: []const u8,49    path: []const u8,50    lang: []const u8,51    stats: *Stats,52};5354const ScriptScanState = struct {55    depth: i64 = 0,56    paren_depth: i64 = 0,57    current_class: ?ScriptFunctionScope = null,58    current_interface: ?ScriptFunctionScope = null,59    current_function: ?ScriptFunctionScope = null,60    skipped_arrow: ?ScriptArrowSkip = null,61};6263const ScriptEnhanceContext = struct {64    allocator: std.mem.Allocator,65    scratch: std.mem.Allocator,66    graph: *graph_mod.Graph,67    module: []const u8,68    path: []const u8,69    source: []const u8,70    stats: *Stats,71};7273const ScriptBody = struct {74    fragment: []const u8,75    braced: bool,76};7778const ScriptMemberObject = struct {79    value: []const u8,80    start: usize,81};8283const ScriptDecl = struct {84    name: []const u8,85    value: []const u8,86};8788pub fn language(lang: []const u8) bool {89    return std.mem.eql(u8, lang, "javascript") or std.mem.eql(u8, lang, "typescript");90}9192pub fn treeParseCandidate(source: []const u8) bool {93    return core.compactParseCandidateAny(source, &.{ "import ", "const ", "let ", "var ", "function ", "async function ", "class ", "interface ", "type ", "export " });94}9596pub fn scan(allocator: std.mem.Allocator, scratch: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, path: []const u8, source: []const u8, source_lines: SourceLines, lang: []const u8, stats: *Stats, limits: smg.ParserLimits) !void {97    const context: ScriptScanContext = .{ .allocator = allocator, .scratch = scratch, .graph = graph, .module = module, .path = path, .lang = lang, .stats = stats };98    var state: ScriptScanState = .{};99    var lines = std.mem.splitScalar(u8, source, '\n');100    var line_no: i64 = 0;101    while (lines.next()) |raw_line| {102        line_no += 1;103        try scanLine(context, &state, raw_line, line_no);104    }105    try enhanceMetadataFromTree(106        allocator,107        scratch,108        graph,109        module,110        path,111        source,112        source_lines,113        lang,114        stats,115        limits,116    );117}118119fn scanLine(context: ScriptScanContext, state: *ScriptScanState, raw_line: []const u8, line_no: i64) !void {120    const trimmed = text.trim(raw_line);121    if (trimmed.len == 0) return;122    const depth_before = state.depth;123    const paren_depth_before = state.paren_depth;124    if (state.skipped_arrow != null) return try continueArrowSkip(context, state, trimmed, line_no);125    if (state.current_function) |function_scope| {126        state.skipped_arrow = try extractCallsOutsideNestedArrows(context.allocator, function_scope.name, trimmed, depth_before, paren_depth_before, context.stats, function_scope.class_name);127    } else if (state.current_class != null and depth_before > state.current_class.?.start_depth) {128        try scanClassLine(context, state, trimmed, line_no, depth_before, paren_depth_before);129    } else if (depth_before == 0) {130        try scanTopLevelLine(context, state, trimmed, line_no, depth_before, paren_depth_before);131    }132    try finishLine(context, state, trimmed, line_no);133}134135fn continueArrowSkip(context: ScriptScanContext, state: *ScriptScanState, trimmed: []const u8, line_no: i64) !void {136    state.depth += braceDelta(trimmed);137    state.paren_depth += parenDelta(trimmed);138    const skip = state.skipped_arrow.?;139    const skip_done = switch (skip.kind) {140        .brace => state.depth <= skip.brace_depth,141        .paren => state.paren_depth <= skip.paren_depth,142    };143    if (skip_done) state.skipped_arrow = null;144    try closeScopes(context, state, line_no);145    clampDepths(state);146}147148fn scanClassLine(context: ScriptScanContext, state: *ScriptScanState, trimmed: []const u8, line_no: i64, depth_before: i64, paren_depth_before: i64) !void {149    const class_name = state.current_class.?.name;150    const name = methodName(trimmed) orelse return;151    const full = try addMethodNode(context.allocator, context.graph, class_name, context.path, name, line_no, context.stats);152    if (functionBody(trimmed)) |body| {153        state.skipped_arrow = try extractCallsOutsideNestedArrows(context.allocator, full, body.fragment, depth_before, paren_depth_before, context.stats, class_name);154        if (body.braced and braceDelta(trimmed) > 0) state.current_function = .{ .name = full, .start_line = line_no, .start_depth = depth_before, .class_name = class_name };155    }156}157158fn scanTopLevelLine(context: ScriptScanContext, state: *ScriptScanState, trimmed: []const u8, line_no: i64, depth_before: i64, paren_depth_before: i64) !void {159    try scanImportLine(context, trimmed);160    try scanInterfaceLine(context, state, trimmed, line_no, depth_before);161    try scanClassDeclarationLine(context, state, trimmed, line_no, depth_before);162    try scanConstantLine(context, trimmed, line_no);163    try scanFunctionLine(context, state, trimmed, line_no, depth_before, paren_depth_before);164}165166fn scanImportLine(context: ScriptScanContext, trimmed: []const u8) !void {167    const target = jsImport(trimmed) orelse return;168    const resolved_target = try importTarget(context.allocator, context.scratch, target, context.module, context.path) orelse return;169    try core.addImportEdge(context.allocator, context.graph, context.module, resolved_target, &.{}, context.stats);170}171172fn scanInterfaceLine(context: ScriptScanContext, state: *ScriptScanState, trimmed: []const u8, line_no: i64, depth_before: i64) !void {173    const name = interfaceName(trimmed) orelse return;174    const full = try addInterfaceNode(context.allocator, context.graph, context.module, context.path, name, line_no, context.stats);175    if (braceDelta(trimmed) > 0) state.current_interface = .{ .name = full, .start_line = line_no, .start_depth = depth_before };176}177178fn scanClassDeclarationLine(context: ScriptScanContext, state: *ScriptScanState, trimmed: []const u8, line_no: i64, depth_before: i64) !void {179    const name = className(trimmed) orelse return;180    const full = try addClassNode(context.allocator, context.graph, context.module, context.path, name, line_no, context.stats);181    try addHeritageEdges(context.allocator, context.stats, full, trimmed);182    if (braceDelta(trimmed) > 0) state.current_class = .{ .name = full, .start_line = line_no, .start_depth = depth_before };183}184185fn scanConstantLine(context: ScriptScanContext, trimmed: []const u8, line_no: i64) !void {186    const name = constantName(trimmed) orelse return;187    try addConstantNode(context.allocator, context.graph, context.module, context.path, name, line_no, context.stats);188}189190fn addConstantNode(allocator: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, path: []const u8, name: []const u8, line_no: i64, stats: *Stats) !void {191    const full = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ module, name });192    const meta = try model.sourcePair(allocator, "scan");193    try graph_mod.addNode(graph, .{ .name = full, .type = model.NodeType.constant, .file = path, .line = line_no, .end_line = line_no, .metadata = meta });194    try core.addScanEdge(graph, stats, .{ .source = module, .rel = model.RelType.contains, .target = full, .metadata = meta });195    stats.nodes_added += 1;196    try core.countType(stats, allocator, model.NodeType.constant);197}198199fn scanFunctionLine(context: ScriptScanContext, state: *ScriptScanState, trimmed: []const u8, line_no: i64, depth_before: i64, paren_depth_before: i64) !void {200    const name = functionName(trimmed) orelse return;201    const full = try addFunctionNode(context.allocator, context.graph, context.module, context.path, name, line_no, context.stats);202    if (functionBody(trimmed)) |body| {203        state.skipped_arrow = try extractCallsOutsideNestedArrows(context.allocator, full, body.fragment, depth_before, paren_depth_before, context.stats, null);204        if (body.braced) state.current_function = .{ .name = full, .start_line = line_no, .start_depth = depth_before };205    }206}207208fn finishLine(context: ScriptScanContext, state: *ScriptScanState, trimmed: []const u8, line_no: i64) !void {209    state.depth += braceDelta(trimmed);210    state.paren_depth += parenDelta(trimmed);211    try closeScopes(context, state, line_no);212    clampDepths(state);213}214215fn closeScopes(context: ScriptScanContext, state: *ScriptScanState, line_no: i64) !void {216    if (state.current_function) |function_scope| {217        if (state.depth <= function_scope.start_depth) {218            try updateFunctionNodeEnd(context.allocator, context.graph, function_scope.name, context.path, function_scope.start_line, line_no);219            state.current_function = null;220        }221    }222    if (state.current_class) |class_scope| {223        if (state.depth <= class_scope.start_depth) {224            try updateNodeEnd(context.allocator, context.graph, class_scope.name, context.path, class_scope.start_line, line_no);225            state.current_class = null;226        }227    }228    if (state.current_interface) |interface_scope| {229        if (state.depth <= interface_scope.start_depth) {230            try updateNodeEnd(context.allocator, context.graph, interface_scope.name, context.path, interface_scope.start_line, line_no);231            state.current_interface = null;232        }233    }234}235236fn clampDepths(state: *ScriptScanState) void {237    if (state.depth < 0) state.depth = 0;238    if (state.paren_depth < 0) state.paren_depth = 0;239}240241fn addFunctionNode(allocator: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, path: []const u8, name: []const u8, line_no: i64, stats: *Stats) ![]const u8 {242    const full = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ module, name });243    const meta = try model.sourcePair(allocator, "scan");244    try graph_mod.addNode(graph, .{ .name = full, .type = model.NodeType.function, .file = path, .line = line_no, .end_line = line_no, .metadata = meta });245    try core.addScanEdge(graph, stats, .{ .source = module, .rel = model.RelType.contains, .target = full, .metadata = meta });246    stats.nodes_added += 1;247    try core.countType(stats, allocator, model.NodeType.function);248    return full;249}250251fn addClassNode(allocator: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, path: []const u8, name: []const u8, line_no: i64, stats: *Stats) ![]const u8 {252    const full = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ module, name });253    const meta = try model.sourcePair(allocator, "scan");254    try graph_mod.addNode(graph, .{ .name = full, .type = model.NodeType.class, .file = path, .line = line_no, .end_line = line_no, .metadata = meta });255    try core.addScanEdge(graph, stats, .{ .source = module, .rel = model.RelType.contains, .target = full, .metadata = meta });256    stats.nodes_added += 1;257    try core.countType(stats, allocator, model.NodeType.class);258    return full;259}260261fn addInterfaceNode(allocator: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, path: []const u8, name: []const u8, line_no: i64, stats: *Stats) ![]const u8 {262    const full = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ module, name });263    const meta = try model.sourcePair(allocator, "scan");264    try graph_mod.addNode(graph, .{ .name = full, .type = model.NodeType.interface, .file = path, .line = line_no, .end_line = line_no, .metadata = meta });265    try core.addScanEdge(graph, stats, .{ .source = module, .rel = model.RelType.contains, .target = full, .metadata = meta });266    stats.nodes_added += 1;267    try core.countType(stats, allocator, model.NodeType.interface);268    return full;269}270271fn addMethodNode(allocator: std.mem.Allocator, graph: *graph_mod.Graph, class_name: []const u8, path: []const u8, name: []const u8, line_no: i64, stats: *Stats) ![]const u8 {272    const full = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ class_name, name });273    const meta = try model.sourcePair(allocator, "scan");274    try graph_mod.addNode(graph, .{ .name = full, .type = model.NodeType.method, .file = path, .line = line_no, .end_line = line_no, .metadata = meta });275    try core.addScanEdge(graph, stats, .{ .source = class_name, .rel = model.RelType.contains, .target = full, .metadata = meta });276    stats.nodes_added += 1;277    try core.countType(stats, allocator, model.NodeType.method);278    return full;279}280281fn updateFunctionNodeEnd(allocator: std.mem.Allocator, graph: *graph_mod.Graph, name: []const u8, path: []const u8, line: i64, end_line: i64) !void {282    try updateNodeEnd(allocator, graph, name, path, line, end_line);283}284285fn updateNodeEnd(allocator: std.mem.Allocator, graph: *graph_mod.Graph, name: []const u8, path: []const u8, line: i64, end_line: i64) !void {286    _ = allocator;287    const existing = graph_mod.getNode(graph, name) orelse return;288    try graph_mod.addNode(graph, .{ .name = name, .type = existing.type, .file = path, .line = line, .end_line = end_line, .metadata = existing.metadata });289}290291fn enhanceMetadataFromTree(allocator: std.mem.Allocator, scratch: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, path: []const u8, source: []const u8, source_lines: SourceLines, lang: []const u8, stats: *Stats, limits: smg.ParserLimits) !void {292    if (!treeParseCandidate(source)) return try enhanceMetadataFromText(allocator, graph, path, source_lines, stats);293    const parsed: ?tree.Parsed = if (std.mem.eql(u8, lang, "javascript"))294        try tree.parseJavaScript(scratch, source, limits)295    else if (std.mem.eql(u8, lang, "typescript") and std.mem.endsWith(u8, path, ".tsx"))296        try tree.parseTsx(scratch, source, limits)297    else if (std.mem.eql(u8, lang, "typescript"))298        try tree.parseTypeScript(scratch, source, limits)299    else300        return;301    const parsed_value = parsed orelse return try enhanceMetadataFromText(allocator, graph, path, source_lines, stats);302    defer tree.deinit(parsed_value);303    try enhanceBody(allocator, scratch, graph, module, path, source, tree.root(parsed_value), stats);304}305306fn enhanceMetadataFromText(allocator: std.mem.Allocator, graph: *graph_mod.Graph, path: []const u8, source_lines: SourceLines, stats: *Stats) !void {307    for (graph.nodes.items) |*node| {308        const file = node.file orelse continue;309        if (!std.mem.eql(u8, file, path)) continue;310        const line = node.line orelse continue;311        const end_line = node.end_line orelse line;312        if (std.mem.eql(u8, node.type, model.NodeType.function) or std.mem.eql(u8, node.type, model.NodeType.method)) {313            node.metadata = try model.mergePairs(allocator, node.metadata, try textFunctionMetadata(allocator, stats.metricInputAllocator(allocator), source_lines, line, end_line, .javascript));314        } else if (std.mem.eql(u8, node.type, model.NodeType.class)) {315            node.metadata = try model.mergePairs(allocator, node.metadata, try textSpanMetadata(allocator, source_lines, line, end_line, null));316        }317    }318}319320fn enhanceBody(allocator: std.mem.Allocator, scratch: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, path: []const u8, source: []const u8, node: tree.Node, stats: *Stats) !void {321    const context: ScriptEnhanceContext = .{ .allocator = allocator, .scratch = scratch, .graph = graph, .module = module, .path = path, .source = source, .stats = stats };322    const children = tree.childCount(node);323    for (0..children) |raw_index| {324        const child_node = tree.child(node, @intCast(raw_index));325        try enhanceChild(context, child_node);326    }327}328329fn enhanceChild(context: ScriptEnhanceContext, node: tree.Node) anyerror!void {330    const node_kind = tree.kind(node);331    if (try enhanceImportChild(context, node_kind, node)) return;332    if (try enhanceNamedDeclarationChild(context, node_kind, node)) return;333    if (try enhanceVariableChild(context, node_kind, node)) return;334    if (std.mem.eql(u8, node_kind, "export_statement")) {335        try enhanceImport(context.allocator, context.scratch, context.graph, context.module, context.path, context.source, node, context.stats);336        const children = tree.childCount(node);337        for (0..children) |raw_index| {338            const child_node = tree.child(node, @intCast(raw_index));339            try enhanceChild(context, child_node);340        }341        return;342    }343    try enhanceDefaultFunctionChild(context, node_kind, node);344}345346fn enhanceImportChild(context: ScriptEnhanceContext, node_kind: []const u8, node: tree.Node) !bool {347    if (!std.mem.eql(u8, node_kind, "import_statement")) return false;348    try enhanceImport(context.allocator, context.scratch, context.graph, context.module, context.path, context.source, node, context.stats);349    return true;350}351352fn enhanceNamedDeclarationChild(context: ScriptEnhanceContext, node_kind: []const u8, node: tree.Node) !bool {353    if (std.mem.eql(u8, node_kind, "class_declaration")) {354        try enhanceClassDeclaration(context, node);355        return true;356    }357    if (std.mem.eql(u8, node_kind, "interface_declaration")) {358        try enhanceNamedInterface(context, node);359        return true;360    }361    if (std.mem.eql(u8, node_kind, "function_declaration")) {362        try enhanceNamedFunction(context, node);363        return true;364    }365    return false;366}367368fn enhanceClassDeclaration(context: ScriptEnhanceContext, node: tree.Node) !void {369    const name_node = tree.childByField(node, "name") orelse return;370    const raw_name = tree.slice(context.source, name_node);371    const expected_name = try std.fmt.allocPrint(context.scratch, "{s}.{s}", .{ context.module, raw_name });372    const known_class = graph_mod.getNode(context.graph, expected_name) != null;373    const class_name = try enhanceClassNode(context.allocator, context.scratch, context.graph, context.module, context.path, context.source, node, raw_name, context.stats);374    if (!known_class) try addHeritageEdges(context.allocator, context.stats, class_name, tree.slice(context.source, node));375    try enhanceClassBody(context.allocator, context.scratch, context.graph, class_name, context.path, context.source, node, context.stats);376}377378fn enhanceNamedInterface(context: ScriptEnhanceContext, node: tree.Node) !void {379    const name_node = tree.childByField(node, "name") orelse return;380    try enhanceInterfaceNode(context.allocator, context.scratch, context.graph, context.module, context.path, context.source, node, tree.slice(context.source, name_node), context.stats);381}382383fn enhanceNamedFunction(context: ScriptEnhanceContext, node: tree.Node) !void {384    const name_node = tree.childByField(node, "name") orelse return;385    try enhanceFunctionNode(context.allocator, context.scratch, context.graph, context.module, context.path, context.source, node, tree.slice(context.source, name_node), context.stats);386}387388fn enhanceVariableChild(context: ScriptEnhanceContext, node_kind: []const u8, node: tree.Node) !bool {389    if (!std.mem.eql(u8, node_kind, "lexical_declaration") and !std.mem.eql(u8, node_kind, "variable_declaration")) return false;390    try enhanceLexical(context.allocator, context.scratch, context.graph, context.module, context.path, context.source, node, context.stats);391    return true;392}393394fn enhanceDefaultFunctionChild(context: ScriptEnhanceContext, node_kind: []const u8, node: tree.Node) !void {395    if (!std.mem.eql(u8, node_kind, "arrow_function") and !std.mem.eql(u8, node_kind, "function_expression")) return;396    try enhanceFunctionNode(context.allocator, context.scratch, context.graph, context.module, context.path, context.source, node, "default", context.stats);397}398399fn enhanceImport(allocator: std.mem.Allocator, scratch: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, path: []const u8, source: []const u8, node: tree.Node, stats: *Stats) !void {400    const children = tree.childCount(node);401    for (0..children) |raw_index| {402        const child_node = tree.child(node, @intCast(raw_index));403        if (!std.mem.eql(u8, tree.kind(child_node), "string")) continue;404        const raw = core.quoted(tree.slice(source, child_node)) orelse return;405        const target = try importTarget(allocator, scratch, raw, module, path) orelse return;406        if (core.edgeExists(graph.*, module, model.RelType.imports, target) or core.deferredEdgeExists(stats.*, module, model.RelType.imports, target)) return;407        try core.addImportEdge(allocator, graph, module, target, &.{}, stats);408        return;409    }410}411412fn enhanceClassNode(allocator: std.mem.Allocator, scratch: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, path: []const u8, source: []const u8, node: tree.Node, name: []const u8, stats: *Stats) ![]const u8 {413    const qualified = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ module, name });414    try upsertNamedNodeFromTree(allocator, graph, module, qualified, model.NodeType.class, path, tree.startLine(node), tree.endLine(node), try scriptSpanMetadata(allocator, scratch, source, node), stats);415    return qualified;416}417418fn enhanceInterfaceNode(allocator: std.mem.Allocator, scratch: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, path: []const u8, source: []const u8, node: tree.Node, name: []const u8, stats: *Stats) !void {419    const qualified = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ module, name });420    try upsertNamedNodeFromTree(allocator, graph, module, qualified, model.NodeType.interface, path, tree.startLine(node), tree.endLine(node), try scriptSpanMetadata(allocator, scratch, source, node), stats);421}422423fn enhanceClassBody(allocator: std.mem.Allocator, scratch: std.mem.Allocator, graph: *graph_mod.Graph, class_name: []const u8, path: []const u8, source: []const u8, node: tree.Node, stats: *Stats) !void {424    const body = tree.childByField(node, "body") orelse core.findChild(node, "class_body") orelse return;425    const children = tree.childCount(body);426    for (0..children) |raw_index| {427        const child_node = tree.child(body, @intCast(raw_index));428        if (!std.mem.eql(u8, tree.kind(child_node), "method_definition")) continue;429        const name_node = tree.childByField(child_node, "name") orelse core.findChild(child_node, "property_identifier") orelse core.findChild(child_node, "identifier") orelse continue;430        try enhanceMethodNode(allocator, scratch, graph, class_name, path, source, child_node, tree.slice(source, name_node), stats);431    }432}433434fn enhanceMethodNode(allocator: std.mem.Allocator, scratch: std.mem.Allocator, graph: *graph_mod.Graph, class_name: []const u8, path: []const u8, source: []const u8, node: tree.Node, name: []const u8, stats: *Stats) !void {435    const qualified = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ class_name, name });436    try upsertNamedNodeFromTree(allocator, graph, class_name, qualified, model.NodeType.method, path, tree.startLine(node), tree.endLine(node), try javascriptFunctionMetadata(allocator, scratch, stats.metricInputAllocator(allocator), source, node), stats);437    try extractTreeCalls(allocator, source, qualified, node, stats, class_name);438}439440fn enhanceLexical(allocator: std.mem.Allocator, scratch: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, path: []const u8, source: []const u8, node: tree.Node, stats: *Stats) !void {441    const children = tree.childCount(node);442    for (0..children) |raw_index| {443        const child_node = tree.child(node, @intCast(raw_index));444        if (!std.mem.eql(u8, tree.kind(child_node), "variable_declarator")) continue;445        const name_node = tree.childByField(child_node, "name") orelse continue;446        if (!std.mem.eql(u8, tree.kind(name_node), "identifier")) continue;447        const value_node = tree.childByField(child_node, "value") orelse continue;448        const value_kind = tree.kind(value_node);449        if (!std.mem.eql(u8, value_kind, "arrow_function") and !std.mem.eql(u8, value_kind, "function_expression")) continue;450        try enhanceFunctionNode(allocator, scratch, graph, module, path, source, value_node, tree.slice(source, name_node), stats);451    }452}453454fn enhanceFunctionNode(allocator: std.mem.Allocator, scratch: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, path: []const u8, source: []const u8, node: tree.Node, name: []const u8, stats: *Stats) !void {455    const qualified = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ module, name });456    try upsertNamedNodeFromTree(allocator, graph, module, qualified, model.NodeType.function, path, tree.startLine(node), tree.endLine(node), try javascriptFunctionMetadata(allocator, scratch, stats.metricInputAllocator(allocator), source, node), stats);457    try extractTreeCalls(allocator, source, qualified, node, stats, null);458}459460fn upsertNamedNodeFromTree(allocator: std.mem.Allocator, graph: *graph_mod.Graph, parent: []const u8, name: []const u8, node_type: []const u8, path: []const u8, line: i64, end_line: i64, metadata: []const model.Pair, stats: *Stats) !void {461    const exists = graph.node_index.contains(name);462    try graph_mod.addNode(graph, .{ .name = name, .type = node_type, .file = path, .line = line, .end_line = end_line, .metadata = metadata });463    if (exists) return;464    try core.addScanEdge(graph, stats, .{ .source = parent, .rel = model.RelType.contains, .target = name, .metadata = try model.sourcePair(allocator, "scan") });465    stats.nodes_added += 1;466    try core.countType(stats, allocator, node_type);467}468469fn extractTreeCalls(allocator: std.mem.Allocator, source: []const u8, caller: []const u8, node: tree.Node, stats: *Stats, class_name: ?[]const u8) !void {470    const body = tree.childByField(node, "body") orelse core.findChild(node, "statement_block") orelse return;471    try extractTreeCallsFromNode(allocator, source, caller, body, stats, class_name);472}473474fn extractTreeCallsFromNode(allocator: std.mem.Allocator, source: []const u8, caller: []const u8, node: tree.Node, stats: *Stats, class_name: ?[]const u8) !void {475    const node_kind = tree.kind(node);476    if (std.mem.eql(u8, node_kind, "new_expression")) return;477    if (std.mem.eql(u8, node_kind, "call_expression")) {478        const target = try treeCallTarget(allocator, source, node, class_name) orelse return;479        if (!core.deferredEdgeExists(stats.*, caller, model.RelType.calls, target.name)) try stats.deferred.append(.{ .source = caller, .rel = model.RelType.calls, .target = target.name });480        return;481    }482    const children = tree.childCount(node);483    for (0..children) |raw_index| try extractTreeCallsFromNode(allocator, source, caller, tree.child(node, @intCast(raw_index)), stats, class_name);484}485486fn treeCallTarget(allocator: std.mem.Allocator, source: []const u8, node: tree.Node, class_name: ?[]const u8) !?CallTarget {487    const target_node = tree.childByField(node, "function") orelse core.namedChildByIndex(node, 0) orelse return null;488    const target_kind = tree.kind(target_node);489    if (std.mem.eql(u8, target_kind, "identifier")) {490        const raw = tree.slice(source, target_node);491        if (builtin(raw) or control(raw)) return null;492        return .{ .name = try allocator.dupe(u8, raw), .resolved = false };493    }494    if (!std.mem.eql(u8, target_kind, "member_expression")) return null;495    const object_node = tree.childByField(target_node, "object") orelse core.namedChildByIndex(target_node, 0) orelse return null;496    const property_node = tree.childByField(target_node, "property") orelse core.namedChildByIndex(target_node, 1) orelse return null;497    const object_kind = tree.kind(object_node);498    const property_kind = tree.kind(property_node);499    if ((!std.mem.eql(u8, object_kind, "identifier") and !std.mem.eql(u8, object_kind, "member_expression") and !std.mem.eql(u8, object_kind, "this") and !std.mem.eql(u8, object_kind, "super")) or (!std.mem.eql(u8, property_kind, "identifier") and !std.mem.eql(u8, property_kind, "property_identifier") and !std.mem.eql(u8, property_kind, "private_property_identifier"))) return null;500    const object = tree.slice(source, object_node);501    const property = tree.slice(source, property_node);502    if (builtin(property) or control(property)) return null;503    if (std.mem.eql(u8, object, "this") and class_name != null) return .{ .name = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ class_name.?, property }), .resolved = true };504    if (std.mem.eql(u8, object, "super") or builtin(object)) return null;505    return .{ .name = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ object, property }), .resolved = false };506}507508fn functionBody(trimmed: []const u8) ?ScriptBody {509    if (variableDeclaration(trimmed)) |decl| {510        const value = text.trim(decl.value);511        if (std.mem.indexOf(u8, value, "=>")) |arrow| {512            const body = text.trim(value[arrow + "=>".len ..]);513            if (std.mem.startsWith(u8, body, "{")) return .{ .fragment = body[1..], .braced = true };514            return .{ .fragment = body, .braced = false };515        }516        if (std.mem.startsWith(u8, value, "function")) return bracedBody(value);517    }518    if (defaultFunctionValue(trimmed)) |value| {519        if (std.mem.indexOf(u8, value, "=>")) |arrow| {520            const body = text.trim(value[arrow + "=>".len ..]);521            if (std.mem.startsWith(u8, body, "{")) return .{ .fragment = body[1..], .braced = true };522            return .{ .fragment = body, .braced = false };523        }524        if (std.mem.startsWith(u8, value, "function")) return bracedBody(value);525    }526    return bracedBody(trimmed);527}528529fn bracedBody(trimmed: []const u8) ?ScriptBody {530    const open = std.mem.indexOfScalar(u8, trimmed, '{') orelse return null;531    return .{ .fragment = trimmed[open + 1 ..], .braced = true };532}533534fn extractCallsOutsideNestedArrows(allocator: std.mem.Allocator, caller: []const u8, fragment: []const u8, depth_before: i64, paren_depth_before: i64, stats: *Stats, class_name: ?[]const u8) !?ScriptArrowSkip {535    if (std.mem.indexOf(u8, fragment, "=>")) |arrow| {536        try extractCalls(allocator, caller, fragment[0..arrow], stats, class_name);537        const body = text.trim(fragment[arrow + "=>".len ..]);538        if (std.mem.startsWith(u8, body, "{")) return .{ .kind = .brace, .brace_depth = depth_before, .paren_depth = paren_depth_before };539        if (body.len == 0 or parenDelta(fragment) > 0) return .{ .kind = .paren, .brace_depth = depth_before, .paren_depth = paren_depth_before };540        return null;541    }542    try extractCalls(allocator, caller, fragment, stats, class_name);543    return null;544}545546fn extractCalls(allocator: std.mem.Allocator, caller: []const u8, fragment: []const u8, stats: *Stats, class_name: ?[]const u8) !void {547    if (std.mem.startsWith(u8, text.trim(fragment), "//")) return;548    var offset: usize = 0;549    while (offset < fragment.len) {550        const paren_rel = std.mem.indexOfScalar(u8, fragment[offset..], '(') orelse break;551        const paren = offset + paren_rel;552        offset = paren + 1;553        const target = try callTarget(allocator, fragment, paren, class_name) orelse continue;554        try stats.deferred.append(.{ .source = caller, .rel = model.RelType.calls, .target = target.name });555    }556}557558fn callTarget(allocator: std.mem.Allocator, fragment: []const u8, paren: usize, class_name: ?[]const u8) !?CallTarget {559    if (paren == 0) return null;560    var end = paren;561    while (end > 0 and std.ascii.isWhitespace(fragment[end - 1])) end -= 1;562    var start = end;563    while (start > 0 and jsIdentByte(fragment[start - 1])) start -= 1;564    if (start == end) return null;565    var before = start;566    while (before > 0 and std.ascii.isWhitespace(fragment[before - 1])) before -= 1;567    const raw = fragment[start..end];568    if (builtin(raw) or control(raw)) return null;569    if (before > 0 and fragment[before - 1] == '.') {570        const object = memberObject(fragment, before - 1) orelse return null;571        if (precededByNew(fragment, object.start)) return null;572        if (std.mem.eql(u8, object.value, "this") and class_name != null) return .{ .name = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ class_name.?, raw }), .resolved = true };573        if (std.mem.eql(u8, object.value, "super") or builtin(object.value)) return null;574        return .{ .name = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ object.value, raw }), .resolved = false };575    }576    if (precededByNew(fragment, start)) return null;577    return .{ .name = try allocator.dupe(u8, raw), .resolved = false };578}579580fn memberObject(fragment: []const u8, dot: usize) ?ScriptMemberObject {581    if (dot == 0) return null;582    var end = dot;583    while (end > 0 and std.ascii.isWhitespace(fragment[end - 1])) end -= 1;584    var start = end;585    while (start > 0 and (jsIdentByte(fragment[start - 1]) or fragment[start - 1] == '.')) start -= 1;586    if (start == end) return null;587    return .{ .value = fragment[start..end], .start = start };588}589590fn precededByNew(fragment: []const u8, callee_start: usize) bool {591    var end = callee_start;592    while (end > 0 and std.ascii.isWhitespace(fragment[end - 1])) end -= 1;593    var start = end;594    while (start > 0 and jsIdentByte(fragment[start - 1])) start -= 1;595    return start != end and std.mem.eql(u8, fragment[start..end], "new");596}597598fn control(name: []const u8) bool {599    const controls = [_][]const u8{ "if", "for", "while", "switch", "catch", "function", "class", "return", "throw", "await", "new", "typeof", "delete", "void", "super", "of", "in" };600    for (controls) |item| if (std.mem.eql(u8, name, item)) return true;601    return false;602}603604fn builtin(name: []const u8) bool {605    const builtins = [_][]const u8{ "console", "require", "setTimeout", "Promise", "JSON", "Math", "Object", "Array", "String", "Number", "Boolean", "Date", "RegExp", "Error", "Map", "Set", "WeakMap", "WeakSet", "Symbol", "Proxy", "Reflect", "parseInt", "parseFloat", "isNaN", "isFinite", "encodeURI", "encodeURIComponent", "decodeURI", "decodeURIComponent", "fetch", "alert", "confirm", "prompt", "TypeError", "RangeError", "ReferenceError", "SyntaxError" };606    for (builtins) |item| if (std.mem.eql(u8, name, item)) return true;607    return false;608}609610fn jsImport(trimmed: []const u8) ?[]const u8 {611    if (std.mem.startsWith(u8, trimmed, "import ")) {612        if (std.mem.indexOf(u8, trimmed, " from ")) |from| {613            const rest = text.trim(trimmed[from + " from ".len ..]);614            return core.quoted(rest);615        }616        return core.quoted(text.trim(trimmed["import ".len..]));617    }618    if (std.mem.startsWith(u8, trimmed, "require(")) return core.quoted(trimmed["require(".len..]);619    return null;620}621622fn importTarget(allocator: std.mem.Allocator, scratch: std.mem.Allocator, raw: []const u8, module: []const u8, path: []const u8) !?[]const u8 {623    const stripped = scan_files.removeKnownExtension(raw);624    if (std.mem.startsWith(u8, stripped, ".")) return try relativeImportTarget(allocator, scratch, stripped, module, path);625    return try bareImportTarget(allocator, scratch, stripped);626}627628fn bareImportTarget(allocator: std.mem.Allocator, scratch: std.mem.Allocator, raw: []const u8) !?[]const u8 {629    var value = text.trim(raw);630    if (value.len != 0 and value[0] == '@') value = value[1..];631    var parts: std.ArrayList([]const u8) = .empty;632    var split = std.mem.splitScalar(u8, value, '/');633    while (split.next()) |part| {634        const item = text.trim(part);635        if (item.len == 0 or std.mem.eql(u8, item, ".")) continue;636        try parts.append(scratch, item);637    }638    if (parts.items.len != 0 and std.mem.eql(u8, parts.items[parts.items.len - 1], "index")) _ = parts.pop();639    if (parts.items.len == 0) return null;640    return try core.joinDotted(allocator, parts.items);641}642643fn relativeImportTarget(allocator: std.mem.Allocator, scratch: std.mem.Allocator, raw: []const u8, module: []const u8, path: []const u8) !?[]const u8 {644    var resolved: std.ArrayList([]const u8) = .empty;645    var module_split = std.mem.splitScalar(u8, module, '.');646    while (module_split.next()) |part| try resolved.append(scratch, part);647    const stem = scan_files.removeKnownExtension(text.basename(path));648    if (!std.mem.eql(u8, stem, "index") and !std.mem.eql(u8, stem, "__init__") and resolved.items.len != 0) _ = resolved.pop();649    var path_split = std.mem.splitScalar(u8, raw, '/');650    while (path_split.next()) |part| {651        const item = text.trim(part);652        if (item.len == 0 or std.mem.eql(u8, item, ".")) continue;653        if (std.mem.eql(u8, item, "..")) {654            if (resolved.items.len == 0) return null;655            _ = resolved.pop();656            continue;657        }658        try resolved.append(scratch, item);659    }660    if (resolved.items.len != 0 and std.mem.eql(u8, resolved.items[resolved.items.len - 1], "index")) _ = resolved.pop();661    if (resolved.items.len == 0) return null;662    return try core.joinDotted(allocator, resolved.items);663}664665fn className(trimmed: []const u8) ?[]const u8 {666    if (prefixedName(trimmed, "class ")) |name| return name;667    if (prefixedName(trimmed, "export class ")) |name| return name;668    if (prefixedName(trimmed, "export default class ")) |name| return name;669    if (prefixedName(trimmed, "abstract class ")) |name| return name;670    if (prefixedName(trimmed, "export abstract class ")) |name| return name;671    return null;672}673674fn interfaceName(trimmed: []const u8) ?[]const u8 {675    return prefixedName(trimmed, "interface ");676}677678fn addHeritageEdges(allocator: std.mem.Allocator, stats: *Stats, class_name: []const u8, trimmed: []const u8) !void {679    try addHeritageEdgesFor(allocator, stats, class_name, trimmed, "extends", model.RelType.inherits);680    try addHeritageEdgesFor(allocator, stats, class_name, trimmed, "implements", model.RelType.implements);681}682683fn addHeritageEdgesFor(allocator: std.mem.Allocator, stats: *Stats, class_name: []const u8, trimmed: []const u8, keyword: []const u8, rel: []const u8) !void {684    const start = std.mem.indexOf(u8, trimmed, keyword) orelse return;685    var rest = text.trim(trimmed[start + keyword.len ..]);686    const brace = std.mem.indexOfScalar(u8, rest, '{') orelse rest.len;687    rest = text.trim(rest[0..brace]);688    var split = std.mem.splitScalar(u8, rest, ',');689    while (split.next()) |raw| {690        const target = heritageTarget(raw) orelse continue;691        try stats.deferred.append(.{ .source = class_name, .rel = rel, .target = try allocator.dupe(u8, target) });692    }693}694695fn heritageTarget(raw: []const u8) ?[]const u8 {696    const trimmed = text.trim(raw);697    var end: usize = 0;698    while (end < trimmed.len and (jsIdentByte(trimmed[end]) or trimmed[end] == '.')) end += 1;699    if (end == 0) return null;700    return trimmed[0..end];701}702703fn functionName(trimmed: []const u8) ?[]const u8 {704    if (prefixedName(trimmed, "function ")) |name| return name;705    if (prefixedName(trimmed, "async function ")) |name| return name;706    if (prefixedName(trimmed, "export function ")) |name| return name;707    if (prefixedName(trimmed, "export async function ")) |name| return name;708    if (prefixedName(trimmed, "export default function ")) |name| return name;709    if (defaultFunctionValue(trimmed) != null) return "default";710    const decl = variableDeclaration(trimmed) orelse return null;711    const value = text.trim(decl.value);712    if (std.mem.startsWith(u8, value, "function") or arrowValue(value)) return decl.name;713    return null;714}715716fn defaultFunctionValue(trimmed: []const u8) ?[]const u8 {717    if (!std.mem.startsWith(u8, trimmed, "export default ")) return null;718    const value = text.trim(trimmed["export default ".len..]);719    if (std.mem.startsWith(u8, value, "function") or arrowValue(value)) return value;720    return null;721}722723fn prefixedName(trimmed: []const u8, prefix: []const u8) ?[]const u8 {724    if (!std.mem.startsWith(u8, trimmed, prefix)) return null;725    const rest = trimmed[prefix.len..];726    var end: usize = 0;727    while (end < rest.len and jsIdentByte(rest[end])) end += 1;728    if (end == 0) return null;729    return rest[0..end];730}731732fn variableDeclaration(trimmed: []const u8) ?ScriptDecl {733    var rest: []const u8 = undefined;734    var value = trimmed;735    if (std.mem.startsWith(u8, value, "export ")) value = text.trim(value["export ".len..]);736    if (std.mem.startsWith(u8, value, "const ")) {737        rest = value["const ".len..];738    } else if (std.mem.startsWith(u8, value, "let ")) {739        rest = value["let ".len..];740    } else if (std.mem.startsWith(u8, value, "var ")) {741        rest = value["var ".len..];742    } else {743        return null;744    }745    var end: usize = 0;746    while (end < rest.len and jsIdentByte(rest[end])) end += 1;747    if (end == 0) return null;748    const after_name = text.trim(rest[end..]);749    if (!std.mem.startsWith(u8, after_name, "=")) return null;750    return .{ .name = rest[0..end], .value = after_name[1..] };751}752753fn arrowValue(raw: []const u8) bool {754    var value = raw;755    if (std.mem.startsWith(u8, value, "async ")) value = text.trim(value["async ".len..]);756    if (std.mem.startsWith(u8, value, "((")) return false;757    const arrow = std.mem.indexOf(u8, value, "=>") orelse return false;758    const call = std.mem.indexOfScalar(u8, value, '(');759    if (call != null and call.? < arrow and !std.mem.startsWith(u8, value, "(")) return false;760    return true;761}762763fn constantName(trimmed: []const u8) ?[]const u8 {764    const decl = variableDeclaration(trimmed) orelse return null;765    return if (core.isUpper(decl.name)) decl.name else null;766}767768fn methodName(trimmed: []const u8) ?[]const u8 {769    if (std.mem.indexOf(u8, trimmed, "=>") != null) return null;770    const paren = std.mem.indexOfScalar(u8, trimmed, '(') orelse return null;771    var start = paren;772    while (start > 0 and jsIdentByte(trimmed[start - 1])) start -= 1;773    if (start == paren) return null;774    const name = trimmed[start..paren];775    if (control(name)) return null;776    var prefix = text.trim(trimmed[0..start]);777    if (prefix.len != 0) {778        while (true) {779            const before = prefix;780            prefix = trimMethodModifier(prefix, "public");781            prefix = trimMethodModifier(prefix, "private");782            prefix = trimMethodModifier(prefix, "protected");783            prefix = trimMethodModifier(prefix, "static");784            prefix = trimMethodModifier(prefix, "async");785            prefix = trimMethodModifier(prefix, "override");786            prefix = trimMethodModifier(prefix, "get");787            prefix = trimMethodModifier(prefix, "set");788            if (std.mem.eql(u8, before, prefix)) break;789        }790        if (prefix.len != 0) return null;791    }792    return name;793}794795fn trimMethodModifier(value: []const u8, modifier: []const u8) []const u8 {796    if (std.mem.eql(u8, value, modifier)) return "";797    if (std.mem.startsWith(u8, value, modifier) and value.len > modifier.len and std.ascii.isWhitespace(value[modifier.len])) return text.trim(value[modifier.len..]);798    return value;799}800801fn parenDelta(line: []const u8) i64 {802    var delta: i64 = 0;803    for (line) |byte| {804        if (byte == '(') delta += 1;805        if (byte == ')') delta -= 1;806    }807    return delta;808}809810fn jsIdentByte(byte: u8) bool {811    return identByte(byte) or byte == '$';812}