tree-sitter-analyzer 1.9.17.1__py3-none-any.whl

tree_sitter_analyzer/language_loader.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+"""
+Dynamic Language Loader
+
+Handles loading of Tree-sitter language parsers with efficient caching
+and lazy loading for optimal performance.
+"""
+
+import importlib
+from typing import TYPE_CHECKING, Any, Optional
+
+if TYPE_CHECKING:
+    from tree_sitter import Language, Parser
+
+try:
+    import tree_sitter
+
+    TREE_SITTER_AVAILABLE = True
+except ImportError:
+    TREE_SITTER_AVAILABLE = False
+
+from .utils import log_warning
+
+
+class LanguageLoader:
+    """Optimized language loader with enhanced caching"""
+
+    # 対応言語とモジュールのマッピング（最適化：frozendict使用を検討）
+    LANGUAGE_MODULES = {
+        "java": "tree_sitter_java",
+        "javascript": "tree_sitter_javascript",
+        "typescript": "tree_sitter_typescript",
+        "tsx": "tree_sitter_typescript",
+        "python": "tree_sitter_python",
+        "c": "tree_sitter_c",
+        "cpp": "tree_sitter_cpp",
+        "rust": "tree_sitter_rust",
+        "go": "tree_sitter_go",
+        "markdown": "tree_sitter_markdown",
+        "sql": "tree_sitter_sql",
+        "csharp": "tree_sitter_c_sharp",
+        "cs": "tree_sitter_c_sharp",  # C# alias
+    }
+
+    # TypeScript特別処理（TypeScriptとTSX）
+    TYPESCRIPT_DIALECTS = {"typescript": "typescript", "tsx": "tsx"}
+
+    @property
+    def SUPPORTED_LANGUAGES(self) -> list:
+        """サポートされている言語のリストを取得するプロパティ"""
+        return list(self.LANGUAGE_MODULES.keys())
+
+    def __init__(self) -> None:
+        """ローダーを初期化（最適化：事前キャッシュ容量指定）"""
+        self._loaded_languages: dict[str, Language] = {}
+        self._loaded_modules: dict[str, Any] = {}
+        self._availability_cache: dict[str, bool] = {}
+        self._parser_cache: dict[str, Parser] = {}  # パーサーキャッシュ追加
+        self._unavailable_languages: set[str] = set()  # 利用不可言語の記録
+
+    def is_language_available(self, language: str) -> bool:
+        """
+        指定された言語のライブラリが利用可能かチェック
+
+        Args:
+            language: 言語名
+
+        Returns:
+            利用可能性
+        """
+        # 事前に利用不可とわかっている言語は即座に返す
+        if language in self._unavailable_languages:
+            return False
+
+        if language in self._availability_cache:
+            return self._availability_cache[language]
+
+        if not TREE_SITTER_AVAILABLE:
+            self._availability_cache[language] = False
+            self._unavailable_languages.add(language)
+            return False
+
+        module_name = self.LANGUAGE_MODULES.get(language)
+        if not module_name:
+            self._availability_cache[language] = False
+            self._unavailable_languages.add(language)
+            return False
+
+        try:
+            importlib.import_module(module_name)
+            self._availability_cache[language] = True
+            return True
+        except ImportError:
+            self._availability_cache[language] = False
+            self._unavailable_languages.add(language)
+            return False
+
+    def load_language(self, language: str) -> Any | None:
+        """Load and return a tree-sitter Language object for the specified language"""
+        if not TREE_SITTER_AVAILABLE:
+            log_warning("Tree-sitter is not available")
+            return None
+
+        # キャッシュから取得（最適化）
+        if language in self._loaded_languages:
+            return self._loaded_languages[language]
+
+        if not self.is_language_available(language):
+            return None
+
+        try:
+            module_name = self.LANGUAGE_MODULES[language]
+
+            # モジュールキャッシュから取得または新規読み込み
+            if module_name not in self._loaded_modules:
+                self._loaded_modules[module_name] = importlib.import_module(module_name)
+
+            module = self._loaded_modules[module_name]
+
+            # TypeScript特別処理
+            if language in self.TYPESCRIPT_DIALECTS:
+                dialect = self.TYPESCRIPT_DIALECTS[language]
+                if hasattr(module, "language_typescript") and dialect == "typescript":
+                    language_func = module.language_typescript
+                elif hasattr(module, "language_tsx") and dialect == "tsx":
+                    language_func = module.language_tsx
+                elif hasattr(module, "language"):
+                    language_func = module.language
+                else:
+                    return None
+            else:
+                if hasattr(module, "language"):
+                    language_func = module.language
+                else:
+                    return None
+
+            # Language オブジェクト作成（新しいAPI対応）
+            caps_or_lang = language_func()
+
+            # 新しいtree-sitter APIでは、language_func()が直接Languageオブジェクトを返す
+            # 古いAPIではPyCapsuleを返すため、適切に処理する
+            if hasattr(caps_or_lang, "__class__") and "Language" in str(
+                type(caps_or_lang)
+            ):
+                # 既にLanguageオブジェクトの場合はそのまま使用
+                tree_sitter_language = caps_or_lang
+            else:
+                # PyCapsuleの場合は、Languageオブジェクトを作成
+                try:
+                    # Use modern tree-sitter API - PyCapsule should be passed to Language constructor
+                    tree_sitter_language = tree_sitter.Language(caps_or_lang)
+                except Exception as e:
+                    log_warning(f"Failed to create Language object for {language}: {e}")
+                    return None
+
+            self._loaded_languages[language] = tree_sitter_language
+            return tree_sitter_language
+
+        except (ImportError, AttributeError, Exception) as e:
+            log_warning(f"Failed to load language '{language}': {e}")
+            self._unavailable_languages.add(language)
+            return None
+
+    def create_parser_safely(self, language: str) -> Optional["Parser"]:
+        """Create a parser for the specified language with error handling"""
+        if not TREE_SITTER_AVAILABLE:
+            log_warning("Tree-sitter is not available")
+            return None
+
+        # パーサーキャッシュから取得
+        if language in self._parser_cache:
+            return self._parser_cache[language]
+
+        tree_sitter_language = self.load_language(language)
+        if tree_sitter_language is None:
+            return None
+
+        try:
+            # Create parser and set language properly
+            parser = tree_sitter.Parser()
+
+            # Ensure we have a proper Language object
+            if not hasattr(tree_sitter_language, "__class__") or "Language" not in str(
+                type(tree_sitter_language)
+            ):
+                log_warning(
+                    f"Invalid language object for {language}: {type(tree_sitter_language)}"
+                )
+                return None
+
+            # Set language using the preferred method
+            if hasattr(parser, "set_language"):
+                parser.set_language(tree_sitter_language)
+            elif hasattr(parser, "language"):
+                parser.language = tree_sitter_language
+            else:
+                # Try constructor approach as last resort
+                try:
+                    parser = tree_sitter.Parser(tree_sitter_language)
+                except Exception as e:
+                    log_warning(
+                        f"Failed to create parser with language constructor for {language}: {e}"
+                    )
+                    return None
+
+            # Cache and return
+            self._parser_cache[language] = parser
+            return parser
+        except Exception as e:
+            log_warning(f"Failed to create parser for '{language}': {e}")
+            return None
+
+    def create_parser(self, language: str) -> Optional["Parser"]:
+        """Create a parser for the specified language (alias for create_parser_safely)"""
+        return self.create_parser_safely(language)
+
+    def get_supported_languages(self) -> list:
+        """
+        サポートされている言語のリストを取得（最適化：結果キャッシュ）
+
+        Returns:
+            サポート言語のリスト
+        """
+        # 利用可能な言語のみを返す（効率化）
+        return [
+            lang
+            for lang in self.LANGUAGE_MODULES.keys()
+            if lang not in self._unavailable_languages
+            and self.is_language_available(lang)
+        ]
+
+    def clear_cache(self) -> None:
+        """キャッシュをクリア（メモリ管理用）"""
+        self._loaded_languages.clear()
+        self._loaded_modules.clear()
+        self._availability_cache.clear()
+        self._parser_cache.clear()
+        self._unavailable_languages.clear()
+        # 可用性キャッシュもクリア
+        self._availability_cache.clear()
+
+
+# グローバルインスタンス（最適化：シングルトンパターン）
+_loader_instance = None
+
+
+def get_loader() -> "LanguageLoader":
+    """Get singleton loader instance"""
+    global _loader_instance
+    if _loader_instance is None:
+        _loader_instance = LanguageLoader()
+    return _loader_instance
+
+
+# 後方互換性のため
+loader = get_loader()
+
+
+def check_language_availability(language: str) -> bool:
+    """言語の利用可能性をチェック"""
+    return get_loader().is_language_available(language)
+
+
+def create_parser_safely(language: str) -> Optional["Parser"]:
+    """安全にパーサーを作成"""
+    return get_loader().create_parser_safely(language)
+
+
+def load_language(language: str) -> Optional["Language"]:
+    """言語をロード"""
+    return get_loader().load_language(language)

tree_sitter_analyzer/languages/__init__.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""
+Language Plugins
+
+This package contains the core language plugins for the tree-sitter analyzer.
+Each plugin provides language-specific parsing and element extraction capabilities.
+"""
+
+# This file makes the languages directory a Python package
+# Language plugins are automatically discovered by the PluginManager