Repository navigation
Expand file tree
/
Copy pathparser_loader.py
More file actions
136 lines (101 loc) · 4.14 KB
/
Copy pathparser_loader.py
File metadata and controls
136 lines (101 loc) · 4.14 KB
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
from collections.abc import Callable
from typing import Any
from loguru import logger
from tree_sitter import Language, Parser
from .language_config import LANGUAGE_CONFIGS
# Define a type for the language library loaders
LanguageLoader = Callable[[], object] | None
# Import available Tree-sitter languages and correctly type them as Optional
def _import_language_loaders() -> dict[str, LanguageLoader]:
"""Import language loaders with proper error handling and typing."""
loaders: dict[str, LanguageLoader] = {}
try:
from tree_sitter_python import language as python_language_so
loaders["python"] = python_language_so
except ImportError:
loaders["python"] = None
try:
from tree_sitter_javascript import language as javascript_language_so
loaders["javascript"] = javascript_language_so
except ImportError:
loaders["javascript"] = None
try:
from tree_sitter_typescript import language_typescript as typescript_language_so
loaders["typescript"] = typescript_language_so
except ImportError:
loaders["typescript"] = None
try:
from tree_sitter_rust import language as rust_language_so
loaders["rust"] = rust_language_so
except ImportError:
loaders["rust"] = None
try:
from tree_sitter_go import language as go_language_so
loaders["go"] = go_language_so
except ImportError:
loaders["go"] = None
try:
from tree_sitter_scala import language as scala_language_so
loaders["scala"] = scala_language_so
except ImportError:
loaders["scala"] = None
try:
from tree_sitter_java import language as java_language_so
loaders["java"] = java_language_so
except ImportError:
loaders["java"] = None
try:
from tree_sitter_cpp import language as cpp_language_so
loaders["cpp"] = cpp_language_so
except ImportError:
loaders["cpp"] = None
return loaders
_language_loaders = _import_language_loaders()
LANGUAGE_LIBRARIES: dict[str, LanguageLoader | None] = _language_loaders
def load_parsers() -> tuple[dict[str, Parser], dict[str, Any]]:
"""Loads all available Tree-sitter parsers and compiles their queries."""
parsers: dict[str, Parser] = {}
queries: dict[str, Any] = {}
available_languages = []
for lang_name, lang_config in LANGUAGE_CONFIGS.items():
lang_lib = LANGUAGE_LIBRARIES.get(lang_name)
if lang_lib:
try:
language = Language(lang_lib())
parser = Parser(language)
parsers[lang_name] = parser
# Compile queries
function_patterns = " ".join(
[
f"({node_type}) @function"
for node_type in lang_config.function_node_types
]
)
class_patterns = " ".join(
[
f"({node_type}) @class"
for node_type in lang_config.class_node_types
]
)
call_patterns = " ".join(
[
f"({node_type}) @call"
for node_type in lang_config.call_node_types
]
)
queries[lang_name] = {
"functions": language.query(function_patterns),
"classes": language.query(class_patterns),
"calls": language.query(call_patterns) if call_patterns else None,
"config": lang_config,
}
available_languages.append(lang_name)
logger.success(f"Successfully loaded {lang_name} grammar.")
except Exception as e:
logger.warning(f"Failed to load {lang_name} grammar: {e}")
else:
logger.debug(f"Tree-sitter library for {lang_name} not available.")
if not available_languages:
raise RuntimeError("No Tree-sitter languages available.")
logger.info(f"Initialized parsers for: {', '.join(available_languages)}")
return parsers, queries