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"
|