File size: 8,760 Bytes
f764cdf
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
917c16d
 
 
804ecef
917c16d
f764cdf
 
 
 
 
 
 
 
 
 
 
 
917c16d
804ecef
f764cdf
 
 
02ebb32
 
 
 
 
 
 
 
f764cdf
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
917c16d
 
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
"""Reference extraction backends.

The package uses ``tree-sitter-language-pack`` and keeps a conservative regex
fallback so unsupported or malformed files do not stop a 500k-repository batch.
"""

from __future__ import annotations

from dataclasses import dataclass
import re
from functools import lru_cache


@dataclass(frozen=True, slots=True)
class Reference:
    name: str
    kind: str
    evidence: str


LANG_ALIASES = {
    "py": "python", "python": "python", "js": "javascript",
    "jsx": "javascript", "ts": "typescript", "tsx": "typescript",
    "c": "c", "h": "c", "cc": "cpp", "cpp": "cpp", "cxx": "cpp",
    "hpp": "cpp", "go": "go", "java": "java", "cs": "c_sharp",
    "rs": "rust", "rb": "ruby", "php": "php", "kt": "kotlin",
    "swift": "swift", "c++": "cpp", "c#": "csharp", "c_sharp": "csharp",
    "objective-c": "objc", "objective-c++": "objc", "shell": "bash",
    "jupyter notebook": "python", "visual basic": "vb", "f#": "fsharp",
}

# This grammar currently calls abort() on some valid input in the native parser,
# which cannot be recovered as a Python exception. Keep these languages on the
# conservative regex backend so one file cannot kill an entire worker process.
UNSAFE_TREESITTER_LANGUAGES = frozenset({"crystal", "lua"})

PATTERNS: dict[str, tuple[tuple[str, re.Pattern[str]], ...]] = {
    "python": (("import", re.compile(r"^\s*import\s+([\w.]+)|^\s*from\s+([\w.]+)\s+import\b", re.M)),),
    "javascript": (("import", re.compile(r"(?:import|export)\s+(?:[^;\n]*?\s+from\s+)?[\"']([^\"']+)[\"']|require\(\s*[\"']([^\"']+)[\"']\s*\)", re.M)),),
    "typescript": (("import", re.compile(r"(?:import|export)\s+(?:[^;\n]*?\s+from\s+)?[\"']([^\"']+)[\"']|require\(\s*[\"']([^\"']+)[\"']\s*\)", re.M)),),
    "c": (("include", re.compile(r"^\s*#\s*include\s*[<\"]([^>\"]+)[>\"]", re.M)),),
    "cpp": (("include", re.compile(r"^\s*#\s*include\s*[<\"]([^>\"]+)[>\"]", re.M)),),
    "go": (("import", re.compile(r"(?:import\s*\(.*?\)|import)\s*[\"']([^\"']+)[\"']", re.S)),),
    "java": (("import", re.compile(r"^\s*import\s+(?:static\s+)?([\w.]+)", re.M)),),
    "csharp": (("using", re.compile(r"^\s*using\s+(?:static\s+)?([\w.]+)\s*;", re.M)),),
    "rust": (("use", re.compile(r"^\s*(?:pub\s+)?(?:use|mod)\s+([\w:]+)", re.M)),),
    "swift": (("import", re.compile(r"^\s*import\s+(?:class|struct|enum|protocol|func|var|let)?\s*([A-Za-z_][\w.]*)", re.M)),),
    "elixir": (("alias", re.compile(r"^\s*(?:alias|use|import|require)\s+([A-Z][\w.]*)", re.M)),),
    "crystal": (("require", re.compile(r"^\s*require\s+[\"']([^\"']+)[\"']", re.M)),),
    "lua": (("require", re.compile(r"\brequire\s*(?:\(\s*)?[\"']([^\"']+)[\"']\s*\)?", re.M)),),
}


def _is_parser_failure(error: BaseException) -> bool:
    """Catch ordinary parser errors and PyO3 panics, but preserve interrupts."""
    return isinstance(error, Exception) or (
        type(error).__name__ == "PanicException"
        and type(error).__module__.startswith("pyo3_runtime")
    )


def language_name(language: str | None, path: str = "") -> str | None:
    value = (language or path.rsplit(".", 1)[-1] if (language or "." in path) else "").lower()
    return LANG_ALIASES.get(value, value or None)


def regex_references(text: str, language: str | None, path: str = "") -> tuple[Reference, ...]:
    lang = language_name(language, path)
    found: list[Reference] = []
    for kind, pattern in PATTERNS.get(lang or "", ()):
        for match in pattern.finditer(text):
            name = next((group for group in match.groups() if group), "")
            if name:
                found.append(Reference(name, kind, match.group(0).strip()[:240]))
    return tuple(found)


def _normalize_ast_import(statement: str, language: str, items: list[str]) -> tuple[Reference, ...]:
    """Normalize the language pack's grammar-specific ImportInfo.source."""
    references = regex_references(statement, language)
    if references:
        if language == "python" and statement.lstrip().startswith("from "):
            module = references[0].name
            separator = "" if module.endswith(".") else "."
            qualified = [Reference(f"{module}{separator}{item}", "import",
                                   f"tree-sitter: {statement[:220]}")
                         for item in items if item and item != "*"]
            if qualified:
                return tuple(qualified)
        return tuple(Reference(ref.name, ref.kind, f"tree-sitter: {statement[:220]}") for ref in references)
    # Some grammars return only a quoted module path instead of a statement.
    source = statement.strip().strip("'\"")
    if source and not any(char.isspace() for char in source):
        return (Reference(source, "import", f"tree-sitter: {statement[:220]}"),)
    quoted = re.findall(r"[\"']([^\"']+)[\"']", statement)
    if quoted:
        return tuple(Reference(value, "import", f"tree-sitter: {statement[:220]}")
                     for value in quoted)
    generic = re.search(
        r"(?:^|\s)(?:import|use|using|include|require|mod|load)\s+(?:static\s+)?([\w.:/@+-]+)",
        statement,
    )
    if generic:
        return (Reference(generic.group(1).rstrip(";"), "import",
                          f"tree-sitter: {statement[:220]}"),)
    # Python's ``import x`` may expose imported items separately.
    return tuple(Reference(item, "import", f"tree-sitter: {statement[:220]}") for item in items if item)


@lru_cache(maxsize=64)
def _cached_parser(lang: str):
    from tree_sitter_language_pack import get_parser
    return get_parser(lang)


@lru_cache(maxsize=1)
def _downloaded_languages() -> frozenset[str]:
    from tree_sitter_language_pack import downloaded_languages
    return frozenset(downloaded_languages())


def treesitter_references(text: str, language: str | None, path: str = "") -> tuple[Reference, ...] | None:
    """Extract references with the optional language pack.

    Grammar-specific queries are deliberately not hard-coded here.  The
    language-independent AST walk confirms that the grammar can parse the file;
    language patterns still provide the precise import spelling and a stable
    fallback for grammars whose node names vary across versions.
    """
    try:
        from tree_sitter_language_pack import downloaded_languages
    except ImportError:
        return None
    lang = language_name(language, path)
    if not lang:
        return None
    if lang in UNSAFE_TREESITTER_LANGUAGES:
        return None
    # The language pack downloads grammars lazily.  Never trigger a network
    # request from the hot file-scanning loop; callers can prefetch grammars in
    # a separate setup step.  Missing local grammars use the regex backend.
    try:
        if lang not in _downloaded_languages():
            return None
    # The Rust/PyO3 wrapper can surface a parser panic as a BaseException
    # (rather than a normal Exception). A malformed source file must not abort
    # an entire repository batch; fall back to the conservative regex parser.
    except BaseException as error:
        if not _is_parser_failure(error):
            raise
        return None
    try:
        from tree_sitter_language_pack import ProcessConfig, process
        result = process(text, ProcessConfig(
            language=lang, structure=False, imports=True, exports=False,
            comments=False, docstrings=False, symbols=False, diagnostics=True,
            max_source_bytes=2_000_000, parse_timeout_ms=2_000,
        ))
    except BaseException as error:
        if not _is_parser_failure(error):
            raise
        return None
    found: list[Reference] = []
    for item in result.imports:
        found.extend(_normalize_ast_import(item.source, lang, item.items))
    # Not every grammar models dependency constructs as imports (notably
    # C/C++ includes). For those languages use the syntax-specific fallback.
    if not found and lang in PATTERNS:
        return regex_references(text, lang, path)
    # Some grammars omit dependency forms from their generic import model:
    # JavaScript call-form require() and Rust mod declarations.
    if lang in {"javascript", "typescript", "rust"}:
        seen = {(ref.name, ref.kind) for ref in found}
        found.extend(ref for ref in regex_references(text, lang, path)
                     if (ref.name, ref.kind) not in seen)
    return tuple(found)


def extract_references(text: str, language: str | None, path: str = "", *,
                       use_treesitter: bool = True) -> tuple[tuple[Reference, ...], str]:
    if use_treesitter:
        references = treesitter_references(text, language, path)
        if references is not None:
            return references, "tree-sitter"
    return regex_references(text, language, path), "regex"