tiny.smg.scan

1pub const CachedProject = struct {2    stats: Stats,3    hits: usize,4    misses: usize,5    tombstones: usize,6    timing: CachedProjectTiming,7};

1pub const CachedProjectTiming = struct {2    manifest_ns: u64 = 0,3    fragment_read_ns: u64 = 0,4    fragment_validation_ns: u64 = 0,5    fragment_fold_ns: u64 = 0,6    fragment_scan_ns: u64 = 0,7    suffix_index_ns: u64 = 0,8    resolution_ns: u64 = 0,9    call_metrics_ns: u64 = 0,10    manifest_write_ns: u64 = 0,11};

1pub const Preparation = struct {2    plan: reconcile.Plan,3    nodes_removed: usize,4};

1pub fn clonePreparation(allocator: std.mem.Allocator, preparation: Preparation) !Preparation {2    return .{3        .plan = try reconcile.clonePlan(allocator, preparation.plan),4        .nodes_removed = preparation.nodes_removed,5    };6}

1pub fn preparePathsWithOptions(allocator: std.mem.Allocator, graph: *graph_mod.Graph, root: []const u8, paths: []const []const u8, clean: bool, options: Options) !Preparation {2    var stats = Stats{};3    var project_options = options;4    project_options.excludes = try scan_files.projectExcludes(5        allocator,6        root,7        options.excludes,8        options.limits.scan,9    );10    const plan = try reconcile.prepare(11        allocator,12        graph,13        root,14        paths,15        clean,16        project_options,17        &stats,18    );19    return .{ .plan = plan, .nodes_removed = stats.nodes_removed };20}

1pub fn scanPaths(2    allocator: std.mem.Allocator,3    graph: *graph_mod.Graph,4    root: []const u8,5    paths: []const []const u8,6    clean: bool,7    limits: smg.Limits,8) !Stats {9    return try scanPathsWithOptions(10        allocator,11        graph,12        root,13        paths,14        clean,15        .{ .limits = limits },16    );17}

1pub fn scanPathsWithOptions(allocator: std.mem.Allocator, graph: *graph_mod.Graph, root: []const u8, paths: []const []const u8, clean: bool, options: Options) !Stats {2    const preparation = try preparePathsWithOptions(allocator, graph, root, paths, clean, options);3    return try scanPrepared(allocator, graph, root, preparation, options);4}

1pub fn scanPrepared(allocator: std.mem.Allocator, graph: *graph_mod.Graph, root: []const u8, preparation: Preparation, options: Options) !Stats {2    var stats = Stats.init(options.phases orelse allocator);3    stats.nodes_removed = preparation.nodes_removed;4    defer stats.retireDeferred();5    defer stats.retireMetricInputs();6    var phase_arena = std.heap.ArenaAllocator.init(options.phases orelse allocator);7    defer phase_arena.deinit();8    for (preparation.plan.files) |file| {9        _ = phase_arena.reset(.retain_capacity);10        const scratch = phase_arena.allocator();11        const path = try std.fs.path.join(scratch, &.{ root, file });12        const source = text.readFileZ(13            scratch,14            path,15            options.limits.scan.max_source_file_bytes,16        ) catch |err| switch (err) {17            error.StreamTooLong => return error.MaxSourceFileBytesExceeded,18            else => continue,19        };20        try scanFile(21            allocator,22            scratch,23            graph,24            root,25            path,26            source,27            &stats,28            options.limits,29        );30    }31    _ = phase_arena.reset(.free_all);32    try reconcile.finish(allocator, graph, preparation.plan, &stats);33    try graph_mod.buildSuffixIndex(graph);34    try resolveDeferredEdges(35        allocator,36        options.phases orelse allocator,37        graph,38        &stats,39    );40    _ = phase_arena.reset(.retain_capacity);41    try updateCallMetrics(42        allocator,43        phase_arena.allocator(),44        graph,45        preparation.plan.files,46        stats.resolution_failures.items,47    );48    stats.retireDeferred();49    stats.retireMetricInputs();50    return stats;51}

1pub fn scanProjectCached(2    allocator: std.mem.Allocator,3    phases: std.mem.Allocator,4    graph: *graph_mod.Graph,5    root: []const u8,6    state: scan_files.ProjectState,7    executable: scan_files.SourceDigest,8    limits: smg.Limits,9) !CachedProject {10    var timing: CachedProjectTiming = .{};11    var phase_started = sys.time.nanoTimestamp();12    var stats = Stats.init(phases);13    defer stats.retireDeferred();14    defer stats.retireMetricInputs();15    var manifest = try fragment.loadManifest(16        allocator,17        phases,18        root,19        executable,20        limits.scan,21    );22    timing.manifest_ns = elapsedNanoseconds(&phase_started);23    defer manifest.deinit();24    var scratch_arena = std.heap.ArenaAllocator.init(phases);25    defer scratch_arena.deinit();26    var scan_arena = std.heap.ArenaAllocator.init(phases);27    defer scan_arena.deinit();28    var hits: usize = 0;29    var misses: usize = 0;30    var stable = true;31    for (state.sources) |source| {32        const result = try scanProjectSource(33            allocator,34            &scratch_arena,35            &scan_arena,36            graph,37            &stats,38            &manifest,39            root,40            executable,41            source,42            &timing,43            limits,44        );45        switch (result) {46            .hit => hits += 1,47            .miss => misses += 1,48            .changed => {49                misses += 1;50                stable = false;51            },52            .unavailable => stable = false,53        }54    }55    try finishCachedProject(56        allocator,57        phases,58        graph,59        state.sources,60        &stats,61        &timing,62    );63    _ = scratch_arena.reset(.free_all);64    phase_started = sys.time.nanoTimestamp();65    const tombstones = if (stable)66        fragment.writeManifest(67            allocator,68            scratch_arena.allocator(),69            root,70            executable,71            state.project,72            &manifest,73            state.sources,74            limits.scan,75        ) catch 076    else77        0;78    timing.manifest_write_ns = elapsedNanoseconds(&phase_started);79    return .{80        .stats = stats,81        .hits = hits,82        .misses = misses,83        .tombstones = tombstones,84        .timing = timing,85    };86}

1pub const scan = @import("scan/root.zig");

1const pipeline = @import("pipeline/root.zig");23pub const core = @import("core/root.zig");4pub const scan_files = @import("files.zig");5pub const fragment = @import("fragment.zig");6pub const scan_metrics = @import("metrics.zig");7pub const chiclet = @import("chiclet.zig");8pub const clike = @import("clike.zig");9pub const python = @import("python.zig");10pub const reconcile = @import("reconcile/root.zig");11pub const script = @import("script.zig");12pub const source_metadata = @import("source.zig");1314pub const Stats = pipeline.Stats;15pub const Count = pipeline.Count;16pub const SkippedEdgeSample = pipeline.SkippedEdgeSample;17pub const OrphanedManualEdge = pipeline.OrphanedManualEdge;18pub const ResolutionBucket = pipeline.ResolutionBucket;19pub const ResolutionFailure = pipeline.ResolutionFailure;20pub const Options = pipeline.Options;21pub const Preparation = pipeline.Preparation;2223pub const scanPaths = pipeline.scanPaths;24pub const scanPathsWithOptions = pipeline.scanPathsWithOptions;25pub const preparePathsWithOptions = pipeline.preparePathsWithOptions;26pub const clonePreparation = pipeline.clonePreparation;27pub const scanPrepared = pipeline.scanPrepared;28pub const scanProjectCached = pipeline.scanProjectCached;29pub const CachedProject = pipeline.CachedProject;30pub const CachedProjectTiming = pipeline.CachedProjectTiming;3132pub const CallMetricsIndex = @import("metrics.zig").CallMetricsIndex;