tiny.smg.scan.scan_metrics

1const std = @import("std");2const alloc_phase = @import("alloc_phase");3const pretty_json = @import("pretty").json;4const smg = @import("../root.zig");5const core = @import("core/root.zig");6const graph_mod = smg.graph;7const lines_mod = smg.lines;8const model = smg.model;9const spans = smg.span;10const text = smg.text;11const tree = smg.tree;1213const SourceLines = lines_mod.SourceLines;1415pub fn pythonCommentLine(line: []const u8) bool {16    return std.mem.startsWith(u8, line, "#");17}1819pub fn braceDelta(line: []const u8) i64 {20    var delta: i64 = 0;21    for (line) |byte| {22        if (byte == '{') delta += 1;23        if (byte == '}') delta -= 1;24    }25    return delta;26}2728pub fn indentation(line: []const u8) usize {29    var spaces: usize = 0;30    for (line) |byte| {31        if (byte == ' ') spaces += 1 else if (byte == '\t') spaces += 4 else break;32    }33    return spaces;34}3536fn zigBranch(kind: []const u8) bool {37    const branches = [_][]const u8{ "if_statement", "if_expression", "else_clause", "for_statement", "while_statement", "while_expression", "switch_expression", "switch_case", "catch_expression", "try_expression" };38    for (branches) |branch| if (std.mem.eql(u8, kind, branch)) return true;39    return false;40}4142fn zigNesting(kind: []const u8) bool {43    const nested = [_][]const u8{ "if_statement", "if_expression", "for_statement", "while_statement", "while_expression", "switch_expression" };44    for (nested) |item| if (std.mem.eql(u8, kind, item)) return true;45    return false;46}4748pub fn scriptSpanMetadata(allocator: std.mem.Allocator, scratch: std.mem.Allocator, source: []const u8, node: tree.Node) ![]const model.Pair {49    const pairs = try allocator.alloc(model.Pair, 3);50    pairs[0] = .{ .key = try allocator.dupe(u8, "content_hash"), .value = try contentHash(allocator, source, node) };51    pairs[1] = .{ .key = try allocator.dupe(u8, "structure_hash"), .value = try structureHash(allocator, scratch, node) };52    pairs[2] = .{ .key = try allocator.dupe(u8, "source"), .value = try allocator.dupe(u8, "scan") };53    return pairs;54}5556pub fn javascriptFunctionMetadata(allocator: std.mem.Allocator, scratch: std.mem.Allocator, metric_inputs: std.mem.Allocator, source: []const u8, node: tree.Node) ![]const model.Pair {57    const metrics = try computeJavaScriptMetrics(scratch, source, node);58    const pairs = try allocator.alloc(model.Pair, 4);59    pairs[0] = .{ .key = try allocator.dupe(u8, "metrics"), .value = try metricsJson(metric_inputs, metrics, 0, 0), .json = true };60    pairs[1] = .{ .key = try allocator.dupe(u8, "content_hash"), .value = try contentHash(allocator, source, node) };61    pairs[2] = .{ .key = try allocator.dupe(u8, "structure_hash"), .value = try structureHash(allocator, scratch, node) };62    pairs[3] = .{ .key = try allocator.dupe(u8, "source"), .value = try allocator.dupe(u8, "scan") };63    return pairs;64}6566fn computeJavaScriptMetrics(allocator: std.mem.Allocator, source: []const u8, node: tree.Node) !FunctionMetrics {67    var metrics = FunctionMetrics{ .lines_of_code = tree.endLine(node) - tree.startLine(node) + 1 };68    if (tree.childByField(node, "parameters")) |parameters| metrics.parameter_count = countNamedNonComment(parameters);69    if (metrics.parameter_count == 0) {70        if (tree.childByField(node, "formal_parameters")) |parameters| metrics.parameter_count = countNamedNonComment(parameters);71    }72    if (tree.childByField(node, "body")) |body| {73        var increments: i64 = 0;74        const children = tree.childCount(body);75        for (0..children) |raw_index| try walkMetricTree(allocator, source, tree.child(body, @intCast(raw_index)), .javascript, 0, &metrics, &increments);76        metrics.cyclomatic_complexity = 1 + increments;77    }78    return metrics;79}8081fn countNamedNonComment(node: tree.Node) i64 {82    var count_value: i64 = 0;83    const children = tree.childCount(node);84    for (0..children) |raw_index| {85        const child_node = tree.child(node, @intCast(raw_index));86        if (tree.isNamed(child_node) and !hashSkip(tree.kind(child_node))) count_value += 1;87    }88    return count_value;89}9091fn javascriptBranch(kind: []const u8) bool {92    const branches = [_][]const u8{ "if_statement", "else_clause", "for_statement", "while_statement", "do_statement", "for_in_statement", "for_of_statement", "switch_case", "catch_clause", "ternary_expression" };93    for (branches) |branch| if (std.mem.eql(u8, kind, branch)) return true;94    return false;95}9697fn javascriptNesting(kind: []const u8) bool {98    const nested = [_][]const u8{ "if_statement", "for_statement", "while_statement", "do_statement", "for_in_statement", "for_of_statement", "try_statement", "switch_statement" };99    for (nested) |item| if (std.mem.eql(u8, kind, item)) return true;100    return false;101}102103fn javascriptLogicalOperator(source: []const u8, node: tree.Node) bool {104    if (!std.mem.eql(u8, tree.kind(node), "binary_expression")) return false;105    const children = tree.childCount(node);106    for (0..children) |raw_index| {107        const child_node = tree.child(node, @intCast(raw_index));108        if (tree.isNamed(child_node)) continue;109        const token = tree.slice(source, child_node);110        if (std.mem.eql(u8, token, "&&") or std.mem.eql(u8, token, "||") or std.mem.eql(u8, token, "??")) return true;111    }112    const span = tree.slice(source, node);113    return countNeedleOutsideQuotes(span, "&&") != 0 or114        countNeedleOutsideQuotes(span, "||") != 0 or115        countNeedleOutsideQuotes(span, "??") != 0;116}117118pub fn cFunctionMetadata(allocator: std.mem.Allocator, scratch: std.mem.Allocator, metric_inputs: std.mem.Allocator, source: []const u8, node: tree.Node) ![]const model.Pair {119    const metrics = try computeCMetrics(scratch, source, node);120    const pairs = try allocator.alloc(model.Pair, 4);121    pairs[0] = .{ .key = try allocator.dupe(u8, "metrics"), .value = try metricsJson(metric_inputs, metrics, 0, 0), .json = true };122    pairs[1] = .{ .key = try allocator.dupe(u8, "content_hash"), .value = try contentHash(allocator, source, node) };123    pairs[2] = .{ .key = try allocator.dupe(u8, "structure_hash"), .value = try structureHash(allocator, scratch, node) };124    pairs[3] = .{ .key = try allocator.dupe(u8, "source"), .value = try allocator.dupe(u8, "scan") };125    return pairs;126}127128pub fn cDeclarationMetadata(allocator: std.mem.Allocator, scratch: std.mem.Allocator, source: []const u8, node: tree.Node) ![]const model.Pair {129    const pairs = try allocator.alloc(model.Pair, 3);130    pairs[0] = .{ .key = try allocator.dupe(u8, "content_hash"), .value = try contentHash(allocator, source, node) };131    pairs[1] = .{ .key = try allocator.dupe(u8, "structure_hash"), .value = try structureHash(allocator, scratch, node) };132    pairs[2] = .{ .key = try allocator.dupe(u8, "source"), .value = try allocator.dupe(u8, "scan") };133    return pairs;134}135136pub fn cRecordMetadata(allocator: std.mem.Allocator, scratch: std.mem.Allocator, source: []const u8, node: tree.Node, c_kind: []const u8) ![]const model.Pair {137    const pairs = try allocator.alloc(model.Pair, 4);138    pairs[0] = .{ .key = try allocator.dupe(u8, "c_kind"), .value = try allocator.dupe(u8, c_kind) };139    pairs[1] = .{ .key = try allocator.dupe(u8, "content_hash"), .value = try contentHash(allocator, source, node) };140    pairs[2] = .{ .key = try allocator.dupe(u8, "structure_hash"), .value = try structureHash(allocator, scratch, node) };141    pairs[3] = .{ .key = try allocator.dupe(u8, "source"), .value = try allocator.dupe(u8, "scan") };142    return pairs;143}144145pub fn cMacroMetadata(allocator: std.mem.Allocator, scratch: std.mem.Allocator, source: []const u8, node: tree.Node) ![]const model.Pair {146    const pairs = try allocator.alloc(model.Pair, 4);147    pairs[0] = .{ .key = try allocator.dupe(u8, "macro"), .value = try allocator.dupe(u8, "true"), .json = true };148    pairs[1] = .{ .key = try allocator.dupe(u8, "content_hash"), .value = try contentHash(allocator, source, node) };149    pairs[2] = .{ .key = try allocator.dupe(u8, "structure_hash"), .value = try structureHash(allocator, scratch, node) };150    pairs[3] = .{ .key = try allocator.dupe(u8, "source"), .value = try allocator.dupe(u8, "scan") };151    return pairs;152}153154fn computeCMetrics(allocator: std.mem.Allocator, source: []const u8, node: tree.Node) !FunctionMetrics {155    var metrics = FunctionMetrics{ .lines_of_code = tree.endLine(node) - tree.startLine(node) + 1 };156    if (tree.childByField(node, "parameters")) |parameters| metrics.parameter_count = countNamedNonComment(parameters);157    if (metrics.parameter_count == 0) {158        if (tree.childByField(node, "formal_parameters")) |parameters| metrics.parameter_count = countNamedNonComment(parameters);159    }160    if (tree.childByField(node, "body")) |body| {161        var increments: i64 = 0;162        const children = tree.childCount(body);163        for (0..children) |raw_index| try walkMetricTree(allocator, source, tree.child(body, @intCast(raw_index)), .c, 0, &metrics, &increments);164        metrics.cyclomatic_complexity = 1 + increments;165    }166    return metrics;167}168169fn cBranch(kind: []const u8) bool {170    const branches = [_][]const u8{ "if_statement", "else_clause", "for_statement", "while_statement", "do_statement", "switch_statement", "case_statement", "conditional_expression" };171    for (branches) |branch| if (std.mem.eql(u8, kind, branch)) return true;172    return false;173}174175fn cNesting(kind: []const u8) bool {176    const nested = [_][]const u8{ "if_statement", "for_statement", "while_statement", "do_statement", "switch_statement" };177    for (nested) |item| if (std.mem.eql(u8, kind, item)) return true;178    return false;179}180181fn cLogicalOperator(source: []const u8, node: tree.Node) bool {182    if (!std.mem.eql(u8, tree.kind(node), "binary_expression")) return false;183    const children = tree.childCount(node);184    for (0..children) |raw_index| {185        const child_node = tree.child(node, @intCast(raw_index));186        if (tree.isNamed(child_node)) continue;187        const token = tree.slice(source, child_node);188        if (std.mem.eql(u8, token, "&&") or std.mem.eql(u8, token, "||")) return true;189    }190    return false;191}192193pub fn textFunctionMetadata(allocator: std.mem.Allocator, metric_inputs: std.mem.Allocator, source_lines: SourceLines, line: i64, end_line: i64, metric_language: MetricLanguage) ![]const model.Pair {194    const source_span = spans.trimmed(source_lines, line, end_line);195    const metrics = computeTextMetrics(source_span, metric_language);196    const pairs = try allocator.alloc(model.Pair, 4);197    pairs[0] = .{ .key = try allocator.dupe(u8, "metrics"), .value = try metricsJson(metric_inputs, metrics, 0, 0), .json = true };198    pairs[1] = .{ .key = try allocator.dupe(u8, "content_hash"), .value = try textContentHash(allocator, source_span) };199    pairs[2] = .{ .key = try allocator.dupe(u8, "structure_hash"), .value = try textStructureHash(allocator, source_span) };200    pairs[3] = .{ .key = try allocator.dupe(u8, "source"), .value = try allocator.dupe(u8, "scan") };201    return pairs;202}203204pub fn textSpanMetadata(allocator: std.mem.Allocator, source_lines: SourceLines, line: i64, end_line: i64, c_kind: ?[]const u8) ![]const model.Pair {205    const source_span = spans.trimmed(source_lines, line, end_line);206    const include_kind = c_kind != null and !std.mem.eql(u8, c_kind.?, "class");207    const count_value: usize = if (include_kind) 4 else 3;208    const pairs = try allocator.alloc(model.Pair, count_value);209    var index: usize = 0;210    if (include_kind) {211        pairs[index] = .{ .key = try allocator.dupe(u8, "c_kind"), .value = try allocator.dupe(u8, c_kind.?) };212        index += 1;213    }214    pairs[index] = .{ .key = try allocator.dupe(u8, "content_hash"), .value = try textContentHash(allocator, source_span) };215    index += 1;216    pairs[index] = .{ .key = try allocator.dupe(u8, "structure_hash"), .value = try textStructureHash(allocator, source_span) };217    index += 1;218    pairs[index] = .{ .key = try allocator.dupe(u8, "source"), .value = try allocator.dupe(u8, "scan") };219    return pairs;220}221222pub fn textMacroMetadata(allocator: std.mem.Allocator, source_lines: SourceLines, line: i64, end_line: i64) ![]const model.Pair {223    const source_span = spans.trimmed(source_lines, line, end_line);224    const pairs = try allocator.alloc(model.Pair, 4);225    pairs[0] = .{ .key = try allocator.dupe(u8, "macro"), .value = try allocator.dupe(u8, "true"), .json = true };226    pairs[1] = .{ .key = try allocator.dupe(u8, "content_hash"), .value = try textContentHash(allocator, source_span) };227    pairs[2] = .{ .key = try allocator.dupe(u8, "structure_hash"), .value = try textStructureHash(allocator, source_span) };228    pairs[3] = .{ .key = try allocator.dupe(u8, "source"), .value = try allocator.dupe(u8, "scan") };229    return pairs;230}231232fn computeTextMetrics(span: []const u8, metric_language: MetricLanguage) FunctionMetrics {233    if (metric_language == .python) return computePythonTextMetrics(span);234    var state = textMetricState(span);235    var lines = std.mem.splitScalar(u8, span, '\n');236    while (lines.next()) |raw_line| {237        updateBraceTextMetricLine(&state, raw_line, metric_language);238    }239    return finishTextMetricState(&state);240}241242fn computePythonTextMetrics(span: []const u8) FunctionMetrics {243    var state = textMetricState(span);244    var lines = std.mem.splitScalar(u8, span, '\n');245    while (lines.next()) |raw_line| {246        updatePythonTextMetricLine(&state, raw_line);247    }248    return finishTextMetricState(&state);249}250251fn textMetricState(span: []const u8) TextMetricState {252    return .{253        .metrics = .{254            .lines_of_code = textLineCount(span),255            .parameter_count = textParameterCount(span),256        },257    };258}259260fn finishTextMetricState(state: *TextMetricState) FunctionMetrics {261    state.metrics.cyclomatic_complexity = 1 + state.increments;262    return state.metrics;263}264265fn updateBraceTextMetricLine(state: *TextMetricState, raw_line: []const u8, metric_language: MetricLanguage) void {266    const trimmed = text.trim(raw_line);267    if (trimmed.len == 0) return;268    closeBraceTextMetricDepth(state, trimmed);269    const nesting_depth = if (state.depth > 0) state.depth - 1 else 0;270    applyBraceTextBranches(state, trimmed, metric_language, nesting_depth);271    applyTextLogicalMetrics(state, trimmed, metric_language);272    if (metric_language != .zig) state.metrics.return_count += countKeyword(trimmed, "return");273    openBraceTextMetricDepth(state, trimmed);274}275276fn updatePythonTextMetricLine(state: *TextMetricState, raw_line: []const u8) void {277    const trimmed = text.trim(raw_line);278    if (trimmed.len == 0 or pythonCommentLine(trimmed)) return;279    const level = pythonTextIndentLevel(raw_line);280    const branch_depth = if (level > 0) level - 1 else 0;281    applyPythonTextBranches(state, trimmed, level, branch_depth);282    applyTextLogicalMetrics(state, trimmed, .python);283    state.metrics.return_count += countKeywordOutsideQuotes(trimmed, "return");284}285286fn closeBraceTextMetricDepth(state: *TextMetricState, trimmed: []const u8) void {287    state.depth -= leadingCloseBraces(trimmed);288    if (state.depth < 0) state.depth = 0;289}290291fn openBraceTextMetricDepth(state: *TextMetricState, trimmed: []const u8) void {292    state.depth += braceDelta(trimmed);293    if (state.depth < 0) state.depth = 0;294}295296fn applyBraceTextBranches(state: *TextMetricState, trimmed: []const u8, metric_language: MetricLanguage, nesting_depth: i64) void {297    const branches = textBranchCount(trimmed, metric_language);298    if (branches == 0) return;299    state.increments += branches;300    state.metrics.cognitive_complexity += branches * (1 + nesting_depth);301    const branch_depth = nesting_depth + branches;302    if (branch_depth > state.metrics.max_nesting_depth) state.metrics.max_nesting_depth = branch_depth;303}304305fn applyPythonTextBranches(state: *TextMetricState, trimmed: []const u8, level: i64, branch_depth: i64) void {306    const branches = pythonTextBranchCount(trimmed);307    if (branches == 0) return;308    state.increments += branches;309    state.metrics.cognitive_complexity += branches * (1 + branch_depth);310    if (level > state.metrics.max_nesting_depth) state.metrics.max_nesting_depth = level;311}312313fn applyTextLogicalMetrics(state: *TextMetricState, trimmed: []const u8, metric_language: MetricLanguage) void {314    const logical = textLogicalCount(trimmed, metric_language);315    state.increments += logical;316    state.metrics.cognitive_complexity += logical;317}318319fn pythonTextIndentLevel(raw_line: []const u8) i64 {320    return @intCast(indentation(raw_line) / 4);321}322323fn pythonTextBranchCount(line: []const u8) i64 {324    return countKeywordOutsideQuotes(line, "if") +325        countKeywordOutsideQuotes(line, "elif") +326        countKeywordOutsideQuotes(line, "for") +327        countKeywordOutsideQuotes(line, "while") +328        countKeywordOutsideQuotes(line, "except") +329        countKeywordOutsideQuotes(line, "with") +330        countKeywordOutsideQuotes(line, "match") +331        countKeywordOutsideQuotes(line, "case");332}333334fn textLineCount(span: []const u8) i64 {335    if (span.len == 0) return 0;336    var count_value: i64 = 1;337    for (span) |byte| {338        if (byte == '\n') count_value += 1;339    }340    return count_value;341}342343fn textParameterCount(span: []const u8) i64 {344    const open = std.mem.indexOfScalar(u8, span, '(') orelse return 0;345    const rest = span[open + 1 ..];346    const close_rel = std.mem.indexOfScalar(u8, rest, ')') orelse return 0;347    const raw_parameters = text.trim(rest[0..close_rel]);348    if (raw_parameters.len == 0 or std.mem.eql(u8, raw_parameters, "void")) return 0;349    var count_value: i64 = 0;350    var split = std.mem.splitScalar(u8, raw_parameters, ',');351    while (split.next()) |raw| {352        const parameter = text.trim(raw);353        if (parameter.len == 0 or std.mem.eql(u8, parameter, "void")) continue;354        count_value += 1;355    }356    return count_value;357}358359fn textBranchCount(line: []const u8, metric_language: MetricLanguage) i64 {360    _ = metric_language;361    return countKeyword(line, "if") +362        countKeyword(line, "for") +363        countKeyword(line, "while") +364        countKeyword(line, "catch") +365        countKeyword(line, "case") +366        countKeyword(line, "switch");367}368369fn textLogicalCount(line: []const u8, metric_language: MetricLanguage) i64 {370    var count_value = countNeedleOutsideQuotes(line, "&&") + countNeedleOutsideQuotes(line, "||");371    if (metric_language == .javascript) count_value += countNeedleOutsideQuotes(line, "??");372    if (metric_language == .zig or metric_language == .python) count_value += countKeywordOutsideQuotes(line, "and") + countKeywordOutsideQuotes(line, "or");373    return count_value;374}375376fn countNeedleOutsideQuotes(source: []const u8, needle: []const u8) i64 {377    var count_value: i64 = 0;378    var offset: usize = 0;379    while (offset < source.len) {380        if (source[offset] == '"' or source[offset] == '\'') {381            offset = skipQuoted(source, offset);382            continue;383        }384        if (offset + needle.len <= source.len and std.mem.eql(u8, source[offset .. offset + needle.len], needle)) {385            count_value += 1;386            offset += needle.len;387            continue;388        }389        offset += 1;390    }391    return count_value;392}393394fn countKeywordOutsideQuotes(source: []const u8, keyword: []const u8) i64 {395    var count_value: i64 = 0;396    var offset: usize = 0;397    while (offset < source.len) {398        if (source[offset] == '"' or source[offset] == '\'') {399            offset = skipQuoted(source, offset);400            continue;401        }402        if (offset + keyword.len <= source.len and std.mem.eql(u8, source[offset .. offset + keyword.len], keyword)) {403            const before_ok = offset == 0 or !identByte(source[offset - 1]);404            const after = offset + keyword.len;405            const after_ok = after == source.len or !identByte(source[after]);406            if (before_ok and after_ok) count_value += 1;407            offset = after;408            continue;409        }410        offset += 1;411    }412    return count_value;413}414415fn countNeedle(source: []const u8, needle: []const u8) i64 {416    var count_value: i64 = 0;417    var offset: usize = 0;418    while (offset < source.len) {419        const rel = std.mem.indexOf(u8, source[offset..], needle) orelse break;420        count_value += 1;421        offset += rel + needle.len;422    }423    return count_value;424}425426fn countKeyword(source: []const u8, keyword: []const u8) i64 {427    var count_value: i64 = 0;428    var offset: usize = 0;429    while (offset < source.len) {430        const rel = std.mem.indexOf(u8, source[offset..], keyword) orelse break;431        const index = offset + rel;432        const before_ok = index == 0 or !identByte(source[index - 1]);433        const after = index + keyword.len;434        const after_ok = after == source.len or !identByte(source[after]);435        if (before_ok and after_ok) count_value += 1;436        offset = after;437    }438    return count_value;439}440441fn leadingCloseBraces(line: []const u8) i64 {442    var count_value: i64 = 0;443    for (line) |byte| {444        if (byte == '}') {445            count_value += 1;446        } else if (!std.ascii.isWhitespace(byte)) {447            break;448        }449    }450    return count_value;451}452453fn textContentHash(allocator: std.mem.Allocator, span: []const u8) ![]const u8 {454    var hasher = std.hash.XxHash64.init(0);455    hasher.update(span);456    return try hex64(allocator, hasher.final());457}458459fn textStructureHash(allocator: std.mem.Allocator, span: []const u8) ![]const u8 {460    var hasher = std.hash.XxHash64.init(0);461    var index: usize = 0;462    while (index < span.len) {463        const byte = span[index];464        if (std.ascii.isWhitespace(byte)) {465            index += 1;466        } else if (identByte(byte)) {467            hasher.update("_");468            index += 1;469            while (index < span.len and identByte(span[index])) index += 1;470        } else if (std.ascii.isDigit(byte)) {471            hasher.update("_");472            index += 1;473            while (index < span.len and (std.ascii.isDigit(span[index]) or span[index] == '.')) index += 1;474        } else if (byte == '"' or byte == '\'') {475            hasher.update("_");476            index = skipQuoted(span, index);477        } else {478            var single = [_]u8{byte};479            hasher.update(&single);480            index += 1;481        }482    }483    return try hex64(allocator, hasher.final());484}485486pub fn skipQuoted(source: []const u8, start: usize) usize {487    const quote = source[start];488    var index = start + 1;489    while (index < source.len) : (index += 1) {490        if (source[index] == '\\') {491            if (index + 1 < source.len) index += 1;492        } else if (source[index] == quote) {493            return index + 1;494        }495    }496    return source.len;497}498499fn zigLogicalOperator(source: []const u8, node: tree.Node) bool {500    if (!std.mem.eql(u8, tree.kind(node), "binary_expression")) return false;501    const children = tree.childCount(node);502    for (0..children) |raw_index| {503        const child_node = tree.child(node, @intCast(raw_index));504        if (tree.isNamed(child_node)) continue;505        const token = tree.slice(source, child_node);506        if (std.mem.eql(u8, token, "and") or std.mem.eql(u8, token, "or")) return true;507    }508    return false;509}510511pub const FunctionMetrics = struct {512    cyclomatic_complexity: i64 = 1,513    cognitive_complexity: i64 = 0,514    max_nesting_depth: i64 = 0,515    lines_of_code: i64 = 0,516    parameter_count: i64 = 0,517    return_count: i64 = 0,518    unresolved_call_targets: ?i64 = null,519    external_call_targets: ?i64 = null,520};521522const TextMetricState = struct {523    metrics: FunctionMetrics,524    increments: i64 = 0,525    depth: i64 = 0,526};527528pub const MetricLanguage = enum {529    zig,530    javascript,531    c,532    python,533};534535const MetricFrame = struct {536    node: tree.Node,537    depth: i64,538};539540fn walkMetricTree(allocator: std.mem.Allocator, source: []const u8, root: tree.Node, metric_language: MetricLanguage, depth: i64, metrics: *FunctionMetrics, increments: *i64) !void {541    var stack: std.ArrayList(MetricFrame) = .empty;542    defer stack.deinit(allocator);543    try stack.append(allocator, .{ .node = root, .depth = depth });544    while (stack.pop()) |frame| {545        const node = frame.node;546        const node_kind = tree.kind(node);547        if (metricSkip(metric_language, node_kind)) continue;548        if (metricBranch(metric_language, node_kind)) {549            increments.* += 1;550            metrics.cognitive_complexity += 1 + frame.depth;551        }552        if (metricLogicalOperator(metric_language, source, node, node_kind)) {553            increments.* += 1;554            metrics.cognitive_complexity += 1;555        }556        if (metricReturn(metric_language, node_kind)) metrics.return_count += 1;557        const child_depth = if (metricNesting(metric_language, node_kind)) frame.depth + 1 else frame.depth;558        if (child_depth > metrics.max_nesting_depth) metrics.max_nesting_depth = child_depth;559        var index = tree.childCount(node);560        while (index != 0) {561            index -= 1;562            try stack.append(allocator, .{ .node = tree.child(node, @intCast(index)), .depth = child_depth });563        }564    }565}566567fn metricSkip(metric_language: MetricLanguage, kind: []const u8) bool {568    return switch (metric_language) {569        .zig => std.mem.eql(u8, kind, "function_declaration"),570        .javascript => std.mem.eql(u8, kind, "function_declaration") or std.mem.eql(u8, kind, "method_definition") or std.mem.eql(u8, kind, "arrow_function") or std.mem.eql(u8, kind, "class_declaration"),571        .c => std.mem.eql(u8, kind, "function_definition") or std.mem.eql(u8, kind, "class_definition") or std.mem.eql(u8, kind, "class_declaration"),572        .python => hashSkip(kind) or hashNormalize(kind) or std.mem.eql(u8, kind, "function_definition") or std.mem.eql(u8, kind, "class_definition") or std.mem.eql(u8, kind, "decorated_definition"),573    };574}575576fn metricBranch(metric_language: MetricLanguage, kind: []const u8) bool {577    return switch (metric_language) {578        .zig => zigBranch(kind),579        .javascript => javascriptBranch(kind),580        .c => cBranch(kind),581        .python => pythonBranch(kind),582    };583}584585fn metricLogicalOperator(metric_language: MetricLanguage, source: []const u8, node: tree.Node, kind: []const u8) bool {586    return switch (metric_language) {587        .zig => zigLogicalOperator(source, node),588        .javascript => javascriptLogicalOperator(source, node),589        .c => cLogicalOperator(source, node),590        .python => pythonLogicalOperator(kind),591    };592}593594fn metricReturn(metric_language: MetricLanguage, kind: []const u8) bool {595    return switch (metric_language) {596        .zig => false,597        .javascript, .c, .python => std.mem.eql(u8, kind, "return_statement"),598    };599}600601fn metricNesting(metric_language: MetricLanguage, kind: []const u8) bool {602    return switch (metric_language) {603        .zig => zigNesting(kind),604        .javascript => javascriptNesting(kind),605        .c => cNesting(kind),606        .python => pythonNesting(kind),607    };608}609610fn pythonBranch(kind: []const u8) bool {611    const branches = [_][]const u8{ "if_statement", "elif_clause", "for_statement", "while_statement", "except_clause", "with_statement", "conditional_expression", "match_statement", "case_clause" };612    for (branches) |branch| if (std.mem.eql(u8, kind, branch)) return true;613    return false;614}615616fn pythonLogicalOperator(kind: []const u8) bool {617    return std.mem.eql(u8, kind, "boolean_operator");618}619620fn pythonNesting(kind: []const u8) bool {621    const nested = [_][]const u8{ "if_statement", "for_statement", "while_statement", "try_statement", "with_statement", "match_statement" };622    for (nested) |item| if (std.mem.eql(u8, kind, item)) return true;623    return false;624}625626fn metricsJson(627    allocator: std.mem.Allocator,628    metrics: FunctionMetrics,629    fan_in: i64,630    fan_out: i64,631) ![]const u8 {632    var out: std.Io.Writer.Allocating = .init(allocator);633    errdefer out.deinit();634    var json = pretty_json.Writer.init(&out.writer, .minified);635    const object = try json.object();636    try object.field("cyclomatic_complexity", metrics.cyclomatic_complexity);637    try object.field("cognitive_complexity", metrics.cognitive_complexity);638    try object.field("max_nesting_depth", metrics.max_nesting_depth);639    try object.field("lines_of_code", metrics.lines_of_code);640    try object.field("parameter_count", metrics.parameter_count);641    try object.field("return_count", metrics.return_count);642    try object.field("fan_in", fan_in);643    try object.field("fan_out", fan_out);644    try writeResolutionMetrics(object, metrics);645    try object.end();646    return try out.toOwnedSlice();647}648649fn metricsJsonWithCalls(650    allocator: std.mem.Allocator,651    metrics: FunctionMetrics,652    fan_in: i64,653    fan_out: i64,654) ![]const u8 {655    return try metricsJson(allocator, metrics, fan_in, fan_out);656}657658pub fn callMetricsJson(659    allocator: std.mem.Allocator,660    fan_in: i64,661    fan_out: i64,662    metrics: FunctionMetrics,663) ![]const u8 {664    var out: std.Io.Writer.Allocating = .init(allocator);665    errdefer out.deinit();666    var json = pretty_json.Writer.init(&out.writer, .minified);667    const object = try json.object();668    try object.field("fan_in", fan_in);669    try object.field("fan_out", fan_out);670    try writeResolutionMetrics(object, metrics);671    try object.end();672    return try out.toOwnedSlice();673}674675fn writeResolutionMetrics(676    object: pretty_json.Object,677    metrics: FunctionMetrics,678) !void {679    if (metrics.unresolved_call_targets) |count| {680        try object.field("unresolved_call_targets", count);681    }682    if (metrics.external_call_targets) |count| {683        try object.field("external_call_targets", count);684    }685}686687fn contentHash(allocator: std.mem.Allocator, source: []const u8, node: tree.Node) ![]const u8 {688    var hasher = std.hash.XxHash64.init(0);689    hasher.update(source[tree.startByte(node)..tree.endByte(node)]);690    return try hex64(allocator, hasher.final());691}692693fn structureHash(allocator: std.mem.Allocator, scratch: std.mem.Allocator, node: tree.Node) ![]const u8 {694    var hasher = std.hash.XxHash64.init(0);695    try structureHashWalk(scratch, node, &hasher);696    return try hex64(allocator, hasher.final());697}698699const HashFrame = struct {700    node: tree.Node,701    close: bool = false,702};703704fn structureHashWalk(allocator: std.mem.Allocator, root: tree.Node, hasher: *std.hash.XxHash64) !void {705    var stack: std.ArrayList(HashFrame) = .empty;706    defer stack.deinit(allocator);707    try stack.append(allocator, .{ .node = root });708    while (stack.pop()) |frame| {709        if (frame.close) {710            hasher.update(")");711            continue;712        }713        const node = frame.node;714        const node_kind = tree.kind(node);715        if (hashSkip(node_kind)) continue;716        if (hashNormalize(node_kind)) {717            hasher.update("_");718            continue;719        }720        hasher.update(node_kind);721        hasher.update("(");722        try stack.append(allocator, .{ .node = node, .close = true });723        var index = tree.childCount(node);724        while (index != 0) {725            index -= 1;726            const child_node = tree.child(node, @intCast(index));727            if (!hashSkip(tree.kind(child_node))) try stack.append(allocator, .{ .node = child_node });728        }729    }730}731732fn hashSkip(kind: []const u8) bool {733    return std.mem.eql(u8, kind, "comment") or std.mem.eql(u8, kind, "line_comment") or std.mem.eql(u8, kind, "block_comment");734}735736fn hashNormalize(kind: []const u8) bool {737    const normalized = [_][]const u8{ "identifier", "type_identifier", "field_identifier", "string", "string_content", "string_literal", "integer", "integer_literal", "float", "float_literal", "number", "true", "false", "none", "null" };738    for (normalized) |item| if (std.mem.eql(u8, kind, item)) return true;739    return false;740}741742fn hex64(allocator: std.mem.Allocator, value: u64) ![]const u8 {743    var buf: [16]u8 = undefined;744    const hex = "0123456789abcdef";745    var current = value;746    var index = buf.len;747    while (index > 0) {748        index -= 1;749        buf[index] = hex[@as(usize, @intCast(current & 0xf))];750        current >>= 4;751    }752    return try allocator.dupe(u8, &buf);753}754755pub fn identByte(byte: u8) bool {756    return std.ascii.isAlphanumeric(byte) or byte == '_';757}758759const CallMetricsCounts = struct {760    fan_in: usize = 0,761    fan_out: usize = 0,762    unresolved_targets: usize = 0,763    external_targets: usize = 0,764    resolution_known: bool = false,765};766767fn fileMeasured(768    measured_files: []const []const u8,769    file: ?[]const u8,770) bool {771    const name = file orelse return false;772    var lower: usize = 0;773    var upper = measured_files.len;774    while (lower < upper) {775        const middle = lower + (upper - lower) / 2;776        switch (std.mem.order(u8, measured_files[middle], name)) {777            .eq => return true,778            .lt => lower = middle + 1,779            .gt => upper = middle,780        }781    }782    return false;783}784785fn failureLess(786    _: void,787    left: core.ResolutionFailure,788    right: core.ResolutionFailure,789) bool {790    const source_order = std.mem.order(u8, left.source, right.source);791    if (source_order != .eq) return source_order == .lt;792    const left_bucket = @backingInt(left.bucket);793    const right_bucket = @backingInt(right.bucket);794    if (left_bucket != right_bucket) return left_bucket < right_bucket;795    return std.mem.lessThan(u8, left.target, right.target);796}797798fn sameFailure(799    left: core.ResolutionFailure,800    right: core.ResolutionFailure,801) bool {802    return left.bucket == right.bucket and803        std.mem.eql(u8, left.source, right.source) and804        std.mem.eql(u8, left.target, right.target);805}806807pub const CallMetricsIndex = struct {808    pub const Limits = struct {809        nodes: usize,810        failures: usize,811    };812813    pub const Capacity = struct {814        counts: usize,815        failures: usize,816        bytes: usize,817818        pub fn derive(limits: Limits) error{CapacityOverflow}!Capacity {819            const count_bytes = std.math.mul(820                usize,821                limits.nodes,822                @sizeOf(CallMetricsCounts),823            ) catch return error.CapacityOverflow;824            const failure_bytes = std.math.mul(825                usize,826                limits.failures,827                @sizeOf(core.ResolutionFailure),828            ) catch return error.CapacityOverflow;829            return .{830                .counts = limits.nodes,831                .failures = limits.failures,832                .bytes = std.math.add(833                    usize,834                    count_bytes,835                    failure_bytes,836                ) catch return error.CapacityOverflow,837            };838        }839    };840841    pub const InitError = std.mem.Allocator.Error || error{CapacityOverflow};842843    pub const claim: alloc_phase.capacity.Declaration = .{844        .source = .{845            .id = "smg.call_metrics_index",846            .kind = .phase_static,847            .limit_source = .caller,848            .storage = .{849                .covered = &.{850                    .{851                        .id = "one_exact_call_and_resolution_count_record_per_final_graph_node",852                        .lifetime = .steady,853                        .detail = "one exact call and resolution count record per final graph node",854                    },855                    .{856                        .id = "one_sortable_view_record_per_unresolved_deferred_call_target",857                        .lifetime = .steady,858                        .detail = "one sortable view record per unresolved deferred call target",859                    },860                },861                .excluded = &.{862                    "retained graph nodes edges names and metadata",863                    "reset-per-node metrics JSON parse scratch",864                    "final metrics JSON and metadata pair storage",865                },866            },867            .capacity = .{868                .inputs = &.{869                    alloc_phase.capacity.bindInput(Limits, "nodes", "nodes"),870                    alloc_phase.capacity.bindInput(Limits, "failures", "failures"),871                },872                .type_selectors = &.{873                    alloc_phase.capacity.bindType(CallMetricsCounts, "callmetricscounts"),874                    alloc_phase.capacity.bindType(core.ResolutionFailure, "resolution_failure"),875                },876                .nodes = &.{877                    .{ .input = 0 },878                    .{ .scale = .{ .node = 0, .coefficient = .{ .size_of_concrete_type = 0 } } },879                    .{ .input = 1 },880                    .{ .scale = .{ .node = 2, .coefficient = .{ .size_of_concrete_type = 1 } } },881                    .{ .add = .{ .left = 1, .right = 3 } },882                },883                .assertions = &.{.{884                    .scope = .closure_total,885                    .measure = .retained,886                    .relation = .exact,887                    .expression = 4,888                }},889            },890            .overload = .{891                .kind = .reject_before_seal,892                .detail = "checked byte multiplication plus one exact acquisition reject overflow or OOM before activation",893            },894            .risks = .{895                .transitive = .{896                    .status = .open,897                    .detail = "standard graph hash lookup is allocation-free in the witness but lacks a transitive allocation-closure certificate",898                },899                .foreign = .{900                    .status = .excluded,901                    .detail = "the index is process-local caller-owned memory with no operating-system or callback edge",902                },903            },904            .obligations = &.{905                .{ .key = "smg_call_metrics_index_capacity_capacity_model", .role = .capacity_model },906                .{ .key = "smg_call_metrics_index_capacity_overload", .role = .overload },907                .{ .key = "smg_call_metrics_index_oom", .role = .overload },908                .{ .key = "smg_call_metrics_index_sealed_transitive_risk", .role = .transitive_risk },909                .{ .key = "smg_call_metrics_index_sealed_foreign_risk", .role = .foreign_risk },910            },911        },912        .bindings = .{913            .owner = @This(),914            .seal = .{915                .family = alloc_phase.capacity.selector(@This().activate),916                .premise = .{917                    .class = .checked_semantic_fact,918                    .authority = .checker,919                },920            },921            .teardown = .{922                .family = alloc_phase.capacity.selector(@This().deinit),923                .premise = .{924                    .class = .checked_semantic_fact,925                    .authority = .checker,926                },927            },928        },929    };930931    phase: alloc_phase.capacity.Phase,932    capacity: Capacity,933    counts: []CallMetricsCounts,934    failures: []core.ResolutionFailure,935936    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!CallMetricsIndex {937        const capacity = try Capacity.derive(limits);938        const counts = if (capacity.counts == 0)939            @constCast((&[_]CallMetricsCounts{})[0..])940        else941            try allocator.alloc(CallMetricsCounts, capacity.counts);942        errdefer if (counts.len != 0) allocator.free(counts);943        const failures = if (capacity.failures == 0)944            @constCast((&[_]core.ResolutionFailure{})[0..])945        else946            try allocator.alloc(core.ResolutionFailure, capacity.failures);947        return .{948            .phase = .initialization,949            .capacity = capacity,950            .counts = counts,951            .failures = failures,952        };953    }954955    pub fn fill(956        self: *CallMetricsIndex,957        graph: *const graph_mod.Graph,958        measured_files: []const []const u8,959        failures: []const core.ResolutionFailure,960    ) void {961        std.debug.assert(self.phase == .initialization);962        std.debug.assert(graph.nodes.items.len == self.capacity.counts);963        std.debug.assert(failures.len == self.failures.len);964        @memset(self.counts, .{});965        for (graph.nodes.items, 0..) |node, index| {966            const callable = std.mem.eql(967                u8,968                node.type,969                model.NodeType.function,970            ) or std.mem.eql(u8, node.type, model.NodeType.method);971            self.counts[index].resolution_known = callable and972                graph_mod.isScan(node.metadata) and973                fileMeasured(measured_files, node.file);974        }975        for (graph.edges.items) |edge| {976            if (!std.mem.eql(u8, edge.rel, model.RelType.calls)) continue;977            const source = graph.node_index.get(edge.source).?;978            const target = graph.node_index.get(edge.target).?;979            self.counts[source].fan_out += 1;980            self.counts[target].fan_in += 1;981        }982        @memcpy(self.failures, failures);983        std.mem.sort(984            core.ResolutionFailure,985            self.failures,986            {},987            failureLess,988        );989        for (self.failures, 0..) |failure, index| {990            if (index != 0 and sameFailure(self.failures[index - 1], failure)) {991                continue;992            }993            const source = graph.node_index.get(failure.source) orelse continue;994            switch (failure.bucket) {995                .unresolved => self.counts[source].unresolved_targets += 1,996                .external => self.counts[source].external_targets += 1,997            }998            self.counts[source].resolution_known = true;999        }1000    }10011002    pub fn activate(self: *CallMetricsIndex) void {1003        std.debug.assert(self.phase == .initialization);1004        self.phase = .steady;1005    }10061007    pub fn get(self: *const CallMetricsIndex, node: usize) CallMetricsCounts {1008        std.debug.assert(self.phase == .steady);1009        std.debug.assert(node < self.counts.len);1010        return self.counts[node];1011    }10121013    pub fn deinit(self: *CallMetricsIndex, allocator: std.mem.Allocator) void {1014        std.debug.assert(self.phase != .teardown);1015        self.phase = .teardown;1016        if (self.counts.len != 0) allocator.free(self.counts);1017        if (self.failures.len != 0) allocator.free(self.failures);1018        self.* = undefined;1019    }1020};10211022comptime {1023    alloc_phase.capacity.requireAllocatorExactOwnerShape(CallMetricsIndex);1024}10251026pub fn updateCallMetrics(1027    allocator: std.mem.Allocator,1028    scratch: std.mem.Allocator,1029    graph: *graph_mod.Graph,1030    measured_files: []const []const u8,1031    failures: []const core.ResolutionFailure,1032) !void {1033    var counts = try CallMetricsIndex.init(scratch, .{1034        .nodes = graph.nodes.items.len,1035        .failures = failures.len,1036    });1037    defer counts.deinit(scratch);1038    counts.fill(graph, measured_files, failures);1039    counts.activate();1040    var parse_arena = std.heap.ArenaAllocator.init(scratch);1041    defer parse_arena.deinit();1042    for (graph.nodes.items, 0..) |*node, node_index| {1043        const existing = model.pairValue(node.metadata, "metrics");1044        if (!std.mem.eql(u8, node.type, model.NodeType.function) and !std.mem.eql(u8, node.type, model.NodeType.method)) {1045            if (existing) |raw| {1046                const value = try allocator.dupe(u8, raw);1047                std.debug.assert(model.replaceOwnedPairValue(node.metadata, "metrics", value, true));1048            }1049            continue;1050        }1051        _ = parse_arena.reset(.retain_capacity);1052        var metrics = if (existing) |raw|1053            parseMetrics(parse_arena.allocator(), raw) catch FunctionMetrics{}1054        else1055            FunctionMetrics{ .cyclomatic_complexity = 0 };1056        const call_counts = counts.get(node_index);1057        if (call_counts.resolution_known) {1058            metrics.unresolved_call_targets = @intCast(1059                call_counts.unresolved_targets,1060            );1061            metrics.external_call_targets = @intCast(1062                call_counts.external_targets,1063            );1064        }1065        const fan_in = call_counts.fan_in;1066        const fan_out = call_counts.fan_out;1067        if (existing != null) {1068            const value = try metricsJsonWithCalls(1069                allocator,1070                metrics,1071                @intCast(fan_in),1072                @intCast(fan_out),1073            );1074            std.debug.assert(model.replaceOwnedPairValue(node.metadata, "metrics", value, true));1075        } else {1076            const pairs = try allocator.alloc(model.Pair, node.metadata.len + 1);1077            @memcpy(pairs[0..node.metadata.len], node.metadata);1078            pairs[node.metadata.len] = .{1079                .key = try allocator.dupe(u8, "metrics"),1080                .value = try callMetricsJson(1081                    allocator,1082                    @intCast(fan_in),1083                    @intCast(fan_out),1084                    metrics,1085                ),1086                .json = true,1087            };1088            node.metadata = pairs;1089        }1090    }1091}10921093fn parseMetrics(allocator: std.mem.Allocator, raw: []const u8) !FunctionMetrics {1094    const parsed = try std.json.parseFromSlice(std.json.Value, allocator, raw, .{});1095    defer parsed.deinit();1096    const object = switch (parsed.value) {1097        .object => |object| object,1098        else => return error.InvalidMetrics,1099    };1100    return .{1101        .cyclomatic_complexity = jsonInt(object, "cyclomatic_complexity"),1102        .cognitive_complexity = jsonInt(object, "cognitive_complexity"),1103        .max_nesting_depth = jsonInt(object, "max_nesting_depth"),1104        .lines_of_code = jsonInt(object, "lines_of_code"),1105        .parameter_count = jsonInt(object, "parameter_count"),1106        .return_count = jsonInt(object, "return_count"),1107        .unresolved_call_targets = jsonOptionalInt(1108            object,1109            "unresolved_call_targets",1110        ),1111        .external_call_targets = jsonOptionalInt(1112            object,1113            "external_call_targets",1114        ),1115    };1116}11171118fn jsonOptionalInt(object: std.json.ObjectMap, key: []const u8) ?i64 {1119    const value = object.get(key) orelse return null;1120    const integer = switch (value) {1121        .integer => |integer| integer,1122        else => return null,1123    };1124    if (integer < 0) return null;1125    return integer;1126}11271128fn jsonInt(object: std.json.ObjectMap, key: []const u8) i64 {1129    const value = object.get(key) orelse return 0;1130    return switch (value) {1131        .integer => |integer| integer,1132        .float => |float| @intFromFloat(float),1133        else => 0,1134    };1135}11361137test "call metrics index capacity matches an independent node storage model" {1138    comptime {1139        @stardustClaim(1140            @import("alloc_phase").capacity.witness(CallMetricsIndex, "smg_call_metrics_index_capacity_capacity_model"),1141            null,1142            null,1143            null,1144            null,1145            null,1146            null,1147        );1148    }1149    comptime {1150        @stardustClaim(1151            @import("alloc_phase").capacity.witness(CallMetricsIndex, "smg_call_metrics_index_capacity_overload"),1152            null,1153            null,1154            null,1155            null,1156            null,1157            null,1158        );1159    }11601161    for (0..64) |nodes| {1162        const failures = nodes / 2;1163        const capacity = try CallMetricsIndex.Capacity.derive(.{1164            .nodes = nodes,1165            .failures = failures,1166        });1167        try std.testing.expectEqual(nodes, capacity.counts);1168        try std.testing.expectEqual(failures, capacity.failures);1169        try std.testing.expectEqual(1170            nodes * @sizeOf(CallMetricsCounts) +1171                failures * @sizeOf(core.ResolutionFailure),1172            capacity.bytes,1173        );1174    }1175    try std.testing.expectError(1176        error.CapacityOverflow,1177        CallMetricsIndex.Capacity.derive(.{1178            .nodes = std.math.maxInt(usize),1179            .failures = 0,1180        }),1181    );1182}11831184fn checkCallMetricsIndexInitAllocationFailures(allocator: std.mem.Allocator) !void {1185    var index = try CallMetricsIndex.init(allocator, .{1186        .nodes = 3,1187        .failures = 2,1188    });1189    index.deinit(allocator);1190}11911192test "call metrics index initialization cleans allocation failure and retries" {1193    comptime {1194        @stardustClaim(1195            @import("alloc_phase").capacity.witness(CallMetricsIndex, "smg_call_metrics_index_oom"),1196            null,1197            null,1198            null,1199            null,1200            null,1201            null,1202        );1203    }12041205    try std.testing.checkAllAllocationFailures(1206        std.testing.allocator,1207        checkCallMetricsIndexInitAllocationFailures,1208        .{},1209    );1210    var index = try CallMetricsIndex.init(std.testing.allocator, .{1211        .nodes = 1,1212        .failures = 0,1213    });1214    defer index.deinit(std.testing.allocator);1215    index.activate();1216    try std.testing.expectEqual(alloc_phase.capacity.Phase.steady, index.phase);1217}12181219test "call metrics index fills and serves exact call counts while sealed" {1220    comptime {1221        @stardustClaim(1222            @import("alloc_phase").capacity.witness(CallMetricsIndex, "smg_call_metrics_index_sealed_transitive_risk"),1223            null,1224            null,1225            null,1226            null,1227            null,1228            null,1229        );1230    }1231    comptime {1232        @stardustClaim(1233            @import("alloc_phase").capacity.witness(CallMetricsIndex, "smg_call_metrics_index_sealed_foreign_risk"),1234            null,1235            null,1236            null,1237            null,1238            null,1239            null,1240        );1241    }12421243    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);1244    defer arena.deinit();1245    const allocator = arena.allocator();1246    var graph = graph_mod.init(allocator);1247    defer graph_mod.deinit(&graph);1248    try graph_mod.addNode(&graph, .{ .name = "app", .type = model.NodeType.module });1249    try graph_mod.addNode(&graph, .{ .name = "app.run", .type = model.NodeType.function });1250    try graph_mod.addNode(&graph, .{ .name = "app.help", .type = model.NodeType.function });1251    try graph_mod.addEdge(&graph, .{ .source = "app", .rel = model.RelType.contains, .target = "app.run" });1252    try graph_mod.addEdge(&graph, .{ .source = "app.run", .rel = model.RelType.calls, .target = "app.help" });12531254    var phase_allocator = try alloc_phase.SealedPhaseAllocator.init(std.testing.allocator);1255    var index = try CallMetricsIndex.init(1256        phase_allocator.initializationAllocator(),1257        .{1258            .nodes = graph.nodes.items.len,1259            .failures = 0,1260        },1261    );1262    defer {1263        if (phase_allocator.phase() == .initialization) phase_allocator.abortInitialization();1264        if (phase_allocator.phase() == .steady) phase_allocator.beginTeardown();1265        index.deinit(phase_allocator.teardownAllocator());1266        phase_allocator.deinit();1267    }1268    phase_allocator.seal();1269    index.fill(&graph, &.{}, &.{});1270    index.activate();1271    try std.testing.expectEqual(@as(usize, 0), index.get(0).fan_in);1272    try std.testing.expectEqual(@as(usize, 1), index.get(1).fan_out);1273    try std.testing.expectEqual(@as(usize, 1), index.get(2).fan_in);1274}12751276test "call metrics replace the owned metadata value without replacing pair storage" {1277    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);1278    defer arena.deinit();1279    const allocator = arena.allocator();1280    var graph = graph_mod.init(allocator);1281    const metadata = try allocator.alloc(model.Pair, 2);1282    metadata[0] = .{ .key = try allocator.dupe(u8, "metrics"), .value = try allocator.dupe(u8, "{\"cyclomatic_complexity\":2,\"cognitive_complexity\":1,\"max_nesting_depth\":1,\"lines_of_code\":3,\"parameter_count\":0,\"return_count\":1,\"fan_in\":0,\"fan_out\":0}"), .json = true };1283    metadata[1] = .{ .key = try allocator.dupe(u8, "source"), .value = try allocator.dupe(u8, "scan") };1284    try graph_mod.addNode(&graph, .{ .name = "app.run", .type = model.NodeType.function, .metadata = metadata });1285    const metadata_pointer = graph.nodes.items[0].metadata.ptr;12861287    try updateCallMetrics(1288        allocator,1289        std.testing.allocator,1290        &graph,1291        &.{},1292        &.{},1293    );12941295    try std.testing.expectEqual(metadata_pointer, graph.nodes.items[0].metadata.ptr);1296    const metrics = model.pairValue(graph.nodes.items[0].metadata, "metrics").?;1297    try std.testing.expect(std.mem.indexOf(u8, metrics, "\"fan_in\":0") != null);1298    try std.testing.expect(std.mem.indexOf(u8, metrics, "\"fan_out\":0") != null);1299}13001301test "resolution metrics keep missing and malformed evidence unknown" {1302    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);1303    defer arena.deinit();1304    const allocator = arena.allocator();1305    const missing = try parseMetrics(allocator, "{}");1306    try std.testing.expectEqual(1307        @as(?i64, null),1308        missing.unresolved_call_targets,1309    );1310    try std.testing.expectEqual(1311        @as(?i64, null),1312        missing.external_call_targets,1313    );1314    const malformed = try parseMetrics(1315        allocator,1316        "{\"unresolved_call_targets\":\"2\",\"external_call_targets\":-1}",1317    );1318    try std.testing.expectEqual(1319        @as(?i64, null),1320        malformed.unresolved_call_targets,1321    );1322    try std.testing.expectEqual(1323        @as(?i64, null),1324        malformed.external_call_targets,1325    );1326}13271328test "call metrics finalization transfers metrics retained by a non-callable node" {1329    var graph_arena = std.heap.ArenaAllocator.init(std.testing.allocator);1330    defer graph_arena.deinit();1331    const allocator = graph_arena.allocator();1332    var graph = graph_mod.init(allocator);1333    var input_arena = std.heap.ArenaAllocator.init(std.testing.allocator);1334    var input_live = true;1335    defer if (input_live) input_arena.deinit();1336    const input = input_arena.allocator();1337    const metadata = try allocator.alloc(model.Pair, 1);1338    metadata[0] = .{ .key = try allocator.dupe(u8, "metrics"), .value = try input.dupe(u8, "{\"lines_of_code\":6}"), .json = true };1339    try graph_mod.addNode(&graph, .{ .name = "app.tool", .type = model.NodeType.module, .metadata = metadata });13401341    try updateCallMetrics(1342        allocator,1343        std.testing.allocator,1344        &graph,1345        &.{},1346        &.{},1347    );1348    input_arena.deinit();1349    input_live = false;13501351    try std.testing.expectEqualStrings("{\"lines_of_code\":6}", model.pairValue(graph.nodes.items[0].metadata, "metrics").?);1352}

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