File size: 6,116 Bytes
f764cdf
 
 
 
 
 
 
02ebb32
f764cdf
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
02ebb32
 
 
 
 
 
 
 
 
 
 
 
f764cdf
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
"""Repository scanner and path resolver."""

from __future__ import annotations

from pathlib import PurePosixPath
import hashlib

from .repo_extract import _is_parser_failure, extract_references, language_name
from .repo_graph import dependency_first_order, strongly_connected_components
from .repo_model import DependencyEdge, Diagnostic, FileInfo, ReferenceInfo, Repo, RepoInfo
from .repo_planning import build_concatenation_tree
from .repo_resolver import Resolver


SOURCE_EXTENSIONS = {".py", ".js", ".jsx", ".ts", ".tsx", ".c", ".h", ".cc", ".cpp", ".cxx", ".hpp", ".go", ".java", ".cs", ".rs", ".rb", ".php", ".kt", ".swift"}


def _text(content: bytes | str, encoding: str | None) -> str:
    if isinstance(content, str):
        return content
    return content.decode(encoding or "utf-8", errors="replace")


def scan(repo: Repo, *, use_treesitter: bool = True, include_weak: bool = False) -> RepoInfo:
    """Scan one repository revision without mutating or materializing content."""
    files = list(repo.iter_files())
    normalized = {PurePosixPath(file.path).as_posix().lstrip("/"): file for file in files}
    paths = set(normalized)
    texts = {path: _text(file.content, file.encoding) for path, file in normalized.items()}
    resolver = Resolver(texts)
    infos: list[FileInfo] = []
    edges: list[DependencyEdge] = []
    diagnostics: list[Diagnostic] = []
    reference_infos: list[ReferenceInfo] = []
    unresolved = external = ambiguous = parsed = ast_files = fallback_files = 0
    for file in files:
        path = PurePosixPath(file.path).as_posix().lstrip("/")
        raw = file.content if isinstance(file.content, bytes) else file.content.encode()
        text = texts[path]
        lang = language_name(file.language, path)
        try:
            refs, backend = extract_references(text, lang, path, use_treesitter=use_treesitter)
        except BaseException as error:
            # Keep batch processing alive even if a third-party parser raises
            # outside its normal exception hierarchy.
            if not _is_parser_failure(error):
                raise
            refs, backend = extract_references(text, lang, path, use_treesitter=False)
            diagnostics.append(Diagnostic(
                path, "warning", f"reference parser failed: {type(error).__name__}",
                "stackbuild",
            ))
        if backend == "tree-sitter":
            ast_files += 1
        else:
            fallback_files += 1
        if refs:
            parsed += 1
        references: list[str] = []
        for ref in refs:
            resolution = resolver.resolve(path, ref.name, lang)
            reference_infos.append(ReferenceInfo(
                path, ref.name, ref.kind, resolution.status, resolution.target,
                resolution.candidates, resolution.confidence, ref.evidence, resolution.evidence,
            ))
            if resolution.status == "internal" and resolution.target:
                edges.append(DependencyEdge(path, resolution.target, ref.kind,
                                             resolution.confidence, "resolved", ref.evidence))
                references.append(resolution.target)
            elif resolution.status == "ambiguous":
                ambiguous += 1
                if resolution.evidence in {"java-wildcard-package", "go-package",
                                            "c-include-candidates"}:
                    for target in resolution.candidates:
                        if target != path:
                            confidence = (
                                0.75 if resolution.evidence != "c-include-candidates"
                                else 0.65
                            )
                            edges.append(DependencyEdge(path, target, ref.kind, confidence,
                                                        "resolved", ref.evidence))
                elif include_weak:
                    for target in resolution.candidates[:4]:
                        if target != path:
                            edges.append(DependencyEdge(path, target, ref.kind, 0.45, "ambiguous", ref.evidence))
            elif resolution.status == "external":
                external += 1
            elif resolution.status == "unresolved":
                unresolved += 1
        infos.append(FileInfo(path, lang, len(raw), hashlib.sha1(raw).hexdigest(), tuple(references)))
    nodes = sorted(paths)
    edges = list(dict.fromkeys(edges))
    reference_infos = list(dict.fromkeys(reference_infos))
    components = strongly_connected_components(nodes, edges)
    order = dependency_first_order(nodes, edges)
    if unresolved:
        diagnostics.append(Diagnostic("", "info", f"{unresolved} references could not be resolved", "stackbuild"))
    if ambiguous:
        diagnostics.append(Diagnostic("", "info", f"{ambiguous} references have multiple candidates", "stackbuild"))
    sorted_infos = tuple(sorted(infos, key=lambda item: item.path))
    edge_tuple = tuple(edges)
    component_tuple = tuple(components)
    tree = build_concatenation_tree(repo.repo_id, sorted_infos, edge_tuple, order, component_tuple)
    return RepoInfo(repo_id=repo.repo_id, revision_id=repo.revision_id,
                    files=sorted_infos, edges=edge_tuple, topological_order=order,
                    strongly_connected_components=component_tuple,
                    diagnostics=tuple(diagnostics), stats={
        "files": len(files), "parsed_files": parsed, "tree_sitter_files": ast_files,
        "regex_fallback_files": fallback_files,
        "resolved_edges": sum(edge.status == "resolved" for edge in edges),
        "references": len(reference_infos),
        "internal_references": sum(ref.status == "internal" for ref in reference_infos),
        "external_references": sum(ref.status == "external" for ref in reference_infos),
        "unresolved_references": sum(ref.status == "unresolved" for ref in reference_infos),
        "ambiguous_references": sum(ref.status == "ambiguous" for ref in reference_infos),
    }, references=tuple(reference_infos), concatenation_tree=tree)