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