the-stack-go / stackgo /stackbuild /repo_extract.py
s0duku's picture
Add generic native parser fallback and sample recovery
804ecef verified
Raw History Blame Contribute Delete
8.76 kB
"""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"