codegraphcontext-rust 0.5.5__cp310-cp310-win_amd64.whl

codegraphcontext/tools/languages/csharp.py

@@ -0,0 +1,551 @@
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+import re
+from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logger, warning_logger
+from codegraphcontext.utils.tree_sitter_manager import execute_query
+
+CSHARP_QUERIES = {
+    "functions": """
+        (method_declaration
+            name: (identifier) @name
+            parameters: (parameter_list) @params
+        ) @function_node
+        
+        (constructor_declaration
+            name: (identifier) @name
+            parameters: (parameter_list) @params
+        ) @function_node
+        
+        (local_function_statement
+            name: (identifier) @name
+            parameters: (parameter_list) @params
+        ) @function_node
+    """,
+    "classes": """
+        (class_declaration 
+            name: (identifier) @name
+            (base_list)? @bases
+        ) @class
+    """,
+    "interfaces": """
+        (interface_declaration 
+            name: (identifier) @name
+            (base_list)? @bases
+        ) @interface
+    """,
+    "structs": """
+        (struct_declaration 
+            name: (identifier) @name
+            (base_list)? @bases
+        ) @struct
+    """,
+    "enums": """
+        (enum_declaration 
+            name: (identifier) @name
+        ) @enum
+    """,
+    "records": """
+        (record_declaration 
+            name: (identifier) @name
+            (base_list)? @bases
+        ) @record
+    """,
+    "properties": """
+        (property_declaration
+            name: (identifier) @name
+        ) @property
+    """,
+    "imports": """
+        (using_directive) @import
+    """,
+    "calls": """
+        (invocation_expression
+            function: [
+                (identifier) @name
+                (member_access_expression
+                    name: (identifier) @name
+                )
+            ]
+        )
+        
+        (object_creation_expression
+            type: [
+                (identifier) @name
+                (qualified_name) @name
+            ]
+        )
+    """,
+}
+
+class CSharpTreeSitterParser:
+    def __init__(self, generic_parser_wrapper: Any):
+        self.generic_parser_wrapper = generic_parser_wrapper
+        self.language_name = "c_sharp"
+        self.language = generic_parser_wrapper.language
+        self.parser = generic_parser_wrapper.parser
+
+    def parse(self, path: Path, is_dependency: bool = False, index_source: bool = False) -> Dict[str, Any]:
+        try:
+            self.index_source = index_source
+            with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+                source_code = f.read()
+
+            if not source_code.strip():
+                warning_logger(f"Empty or whitespace-only file: {path}")
+                return {
+                    "path": str(path),
+                    "functions": [],
+                    "classes": [],
+                    "interfaces": [],
+                    "structs": [],
+                    "enums": [],
+                    "records": [],
+                    "properties": [],
+                    "variables": [],
+                    "imports": [],
+                    "function_calls": [],
+                    "is_dependency": is_dependency,
+                    "lang": self.language_name,
+                }
+
+            tree = self.parser.parse(bytes(source_code, "utf8"))
+
+            parsed_functions = []
+            parsed_classes = []
+            parsed_interfaces = []
+            parsed_structs = []
+            parsed_enums = []
+            parsed_records = []
+            parsed_properties = []
+            parsed_imports = []
+            parsed_calls = []
+
+            for capture_name, query_str in CSHARP_QUERIES.items():
+                captures = execute_query(self.language, query_str, tree.root_node)
+
+                if capture_name == "functions":
+                    parsed_functions = self._parse_functions(captures, source_code, path, tree.root_node)
+                elif capture_name == "classes":
+                    parsed_classes = self._parse_type_declarations(captures, source_code, path, "Class")
+                elif capture_name == "interfaces":
+                    parsed_interfaces = self._parse_type_declarations(captures, source_code, path, "Interface")
+                elif capture_name == "structs":
+                    parsed_structs = self._parse_type_declarations(captures, source_code, path, "Struct")
+                elif capture_name == "enums":
+                    parsed_enums = self._parse_type_declarations(captures, source_code, path, "Enum")
+                elif capture_name == "records":
+                    parsed_records = self._parse_type_declarations(captures, source_code, path, "Record")
+                elif capture_name == "properties":
+                    parsed_properties = self._parse_properties(captures, source_code, path, tree.root_node)
+                elif capture_name == "imports":
+                    parsed_imports = self._parse_imports(captures, source_code)
+                elif capture_name == "calls":
+                    parsed_calls = self._parse_calls(captures, source_code)
+
+            return {
+                "path": str(path),
+                "functions": parsed_functions,
+                "classes": parsed_classes,
+                "interfaces": parsed_interfaces,
+                "structs": parsed_structs,
+                "enums": parsed_enums,
+                "records": parsed_records,
+                "properties": parsed_properties,
+                "variables": [],
+                "imports": parsed_imports,
+                "function_calls": parsed_calls,
+                "is_dependency": is_dependency,
+                "lang": self.language_name,
+            }
+
+        except Exception as e:
+            error_logger(f"Error parsing C# file {path}: {e}")
+            return {
+                "path": str(path),
+                "functions": [],
+                "classes": [],
+                "interfaces": [],
+                "structs": [],
+                "enums": [],
+                "records": [],
+                "properties": [],
+                "variables": [],
+                "imports": [],
+                "function_calls": [],
+                "is_dependency": is_dependency,
+                "lang": self.language_name,
+            }
+
+    def _parse_functions(self, captures: list, source_code: str, path: Path, root_node) -> list[Dict[str, Any]]:
+        functions = []
+        source_lines = source_code.splitlines()
+
+        for node, capture_name in captures:
+            if capture_name == "function_node":
+                try:
+                    start_line = node.start_point[0] + 1
+                    end_line = node.end_point[0] + 1
+                    
+                    name_captures = [
+                        (n, cn) for n, cn in captures 
+                        if cn == "name" and n.parent.id == node.id
+                    ]
+                    
+                    if name_captures:
+                        name_node = name_captures[0][0]
+                        func_name = self._get_node_text(name_node)
+                        
+                        params_captures = [
+                            (n, cn) for n, cn in captures 
+                            if cn == "params" and n.parent.id == node.id
+                        ]
+                        
+                        parameters = []
+                        if params_captures:
+                            params_node = params_captures[0][0]
+                            parameters = self._extract_parameters(params_node)
+
+                        # Extract attributes applied to this function
+                        attributes = []
+                        if node.parent and node.parent.type == "attribute_list":
+                            attr_text = self._get_node_text(node.parent)
+                            attributes.append(attr_text)
+
+                        # Find containing class/struct/interface
+                        class_context = self._find_containing_type(node, source_code)
+
+                        source_text = self._get_node_text(node)
+                        
+                        func_data = {
+                            "name": func_name,
+                            "args": parameters,
+                            "attributes": attributes,
+                            "line_number": start_line,
+                            "end_line": end_line,
+                            "path": str(path),
+                            "lang": self.language_name,
+                        }
+                        
+                        # Add class context if found
+                        if class_context:
+                            func_data["class_context"] = class_context
+
+                        if self.index_source:
+                            func_data["source"] = source_text
+                        
+                        functions.append(func_data)
+                        
+                except Exception as e:
+                    error_logger(f"Error parsing function in {path}: {e}")
+                    continue
+
+        return functions
+
+    def _parse_type_declarations(self, captures: list, source_code: str, path: Path, type_label: str) -> list[Dict[str, Any]]:
+        """Parse class, interface, struct, enum, or record declarations with inheritance info."""
+        types = []
+        
+        # Map capture names based on type
+        capture_map = {
+            "Class": "class",
+            "Interface": "interface",
+            "Struct": "struct",
+            "Enum": "enum",
+            "Record": "record"
+        }
+        expected_capture = capture_map.get(type_label, "class")
+
+        for node, capture_name in captures:
+            if capture_name == expected_capture:
+                try:
+                    start_line = node.start_point[0] + 1
+                    end_line = node.end_point[0] + 1
+                    
+                    name_captures = [
+                        (n, cn) for n, cn in captures 
+                        if cn == "name" and n.parent.id == node.id
+                    ]
+                    
+                    if name_captures:
+                        name_node = name_captures[0][0]
+                        type_name = self._get_node_text(name_node)
+                        
+                        # Extract base classes/interfaces
+                        bases = []
+                        bases_captures = [
+                            (n, cn) for n, cn in captures 
+                            if cn == "bases" and n.parent.id == node.id
+                        ]
+                        
+                        if bases_captures:
+                            bases_node = bases_captures[0][0]
+                            bases_text = self._get_node_text(bases_node)
+                            # Parse base list: ": BaseClass, IInterface1, IInterface2"
+                            bases_text = bases_text.strip().lstrip(':').strip()
+                            if bases_text:
+                                bases = [b.strip() for b in bases_text.split(',')]
+                        
+                        source_text = self._get_node_text(node)
+                        
+                        type_data = {
+                            "name": type_name,
+                            "line_number": start_line,
+                            "end_line": end_line,
+                            "path": str(path),
+                            "lang": self.language_name,
+                        }
+                        
+                        # Add bases if found
+                        if bases:
+                            type_data["bases"] = bases
+
+                        if self.index_source:
+                            type_data["source"] = source_text
+                        
+                        types.append(type_data)
+                        
+                except Exception as e:
+                    error_logger(f"Error parsing {type_label} in {path}: {e}")
+                    continue
+
+        return types
+
+    def _parse_imports(self, captures: list, source_code: str) -> list[dict]:
+        imports = []
+        
+        for node, capture_name in captures:
+            if capture_name == "import":
+                try:
+                    import_text = self._get_node_text(node)
+                    # Match: using System.Collections.Generic; or using static System.Math;
+                    import_match = re.search(r'using\s+(?:static\s+)?([^;]+)', import_text)
+                    if import_match:
+                        import_path = import_match.group(1).strip()
+                        
+                        # Check for alias: using MyAlias = System.Collections.Generic.List<int>;
+                        alias = None
+                        if '=' in import_path:
+                            parts = import_path.split('=')
+                            alias = parts[0].strip()
+                            import_path = parts[1].strip()
+                        
+                        import_data = {
+                            "name": import_path,
+                            "full_import_name": import_path,
+                            "line_number": node.start_point[0] + 1,
+                            "alias": alias,
+                            "context": (None, None),
+                            "lang": self.language_name,
+                            "is_dependency": False,
+                        }
+                        imports.append(import_data)
+                except Exception as e:
+                    error_logger(f"Error parsing import: {e}")
+                    continue
+
+        return imports
+
+    def _get_parent_context(self, node: Any, types: Tuple[str, ...] = ('class_declaration', 'struct_declaration', 'function_declaration', 'method_declaration')):
+        """Find parent context for C# constructs."""
+        curr = node.parent
+        while curr:
+            if curr.type in types:
+                if curr.type in ('method_declaration', 'function_declaration'):
+                     name_node = curr.child_by_field_name('name')
+                     return self._get_node_text(name_node) if name_node else None, curr.type, curr.start_point[0] + 1
+                else: 
+                     # Classes, structs, etc.
+                     name_node = curr.child_by_field_name('name')
+                     return self._get_node_text(name_node) if name_node else None, curr.type, curr.start_point[0] + 1
+            curr = curr.parent
+        return None, None, None
+
+    def _get_node_text(self, node: Any) -> str:
+        if not node: return ""
+        return node.text.decode("utf-8")
+
+    def _parse_calls(self, captures: list, source_code: str) -> list[dict]:
+        calls = []
+        seen_calls = set()
+        
+        for node, capture_name in captures:
+            if capture_name == "name":
+                try:
+                    call_name = self._get_node_text(node)
+                    line_number = node.start_point[0] + 1
+                    
+                    # Avoid duplicates
+                    call_key = f"{call_name}_{line_number}"
+                    if call_key in seen_calls:
+                        continue
+                    seen_calls.add(call_key)
+                    
+                    # Get context
+                    context_name, context_type, context_line = self._get_parent_context(node)
+                    class_context = context_name if context_type and 'class' in context_type else None
+
+                    call_data = {
+                        "name": call_name,
+                        "full_name": call_name,
+                        "line_number": line_number,
+                        "args": [],
+                        "inferred_obj_type": None,
+                        "context": (context_name, context_type, context_line),
+                        "class_context": class_context,
+                        "lang": self.language_name,
+                        "is_dependency": False,
+                    }
+                    calls.append(call_data)
+                except Exception as e:
+                    error_logger(f"Error parsing call: {e}")
+                    continue
+
+        return calls
+    
+
+    def _extract_parameters(self, params_node) -> list[str]:
+        params = []
+        if not params_node:
+            return params
+            
+        # Iterate over parameter nodes in the parameter list
+        for child in params_node.children:
+            if child.type == "parameter":
+                # find the identifier
+                name_node = child.child_by_field_name("name")
+                if name_node:
+                     params.append(self._get_node_text(name_node))
+                else:
+                    # Fallback: scan children for identifier if field name not present in this grammar version
+                    for sub in child.children:
+                        if sub.type == "identifier":
+                            params.append(self._get_node_text(sub))
+                            break
+        return params
+
+    def _find_containing_type(self, node, source_code):
+        """Find the containing class, struct, interface, or record for a given node."""
+        current = node.parent
+        while current:
+            if current.type in ['class_declaration', 'struct_declaration', 'interface_declaration', 'record_declaration']:
+                # Find the name of this type
+                for child in current.children:
+                    if child.type == 'identifier':
+                        return self._get_node_text(child)
+            current = current.parent
+        return None
+
+    def _parse_properties(self, captures: list, source_code: str, path: Path, root_node) -> list[Dict[str, Any]]:
+        """Parse C# properties."""
+        properties = []
+        
+        for node, capture_name in captures:
+            if capture_name == "property":
+                try:
+                    start_line = node.start_point[0] + 1
+                    end_line = node.end_point[0] + 1
+                    
+                    name_captures = [
+                        (n, cn) for n, cn in captures 
+                        if cn == "name" and n.parent == node
+                    ]
+                    
+                    if name_captures:
+                        name_node = name_captures[0][0]
+                        prop_name = self._get_node_text(name_node)
+                        
+                        # Get property type from node children
+                        prop_type = None
+                        for child in node.children:
+                            if child.type in ['predefined_type', 'identifier', 'generic_name', 'nullable_type', 'array_type']:
+                                prop_type = self._get_node_text(child)
+                                break
+                        
+                        
+                        # Find containing class/struct
+                        class_context = self._find_containing_type(node, source_code)
+                        
+                        source_text = self._get_node_text(node)
+                        
+                        prop_data = {
+                            "name": prop_name,
+                            "type": prop_type,
+                            "line_number": start_line,
+                            "end_line": end_line,
+                            "path": str(path),
+                            "lang": self.language_name,
+                        }
+                        
+                        if class_context:
+                            prop_data["class_context"] = class_context
+                            
+                        if self.index_source:
+                            prop_data["source"] = source_text
+                        
+                        properties.append(prop_data)
+                        
+                except Exception as e:
+                    error_logger(f"Error parsing property in {path}: {e}")
+                    continue
+        
+        return properties
+
+
+
+def pre_scan_csharp(files: list[Path], parser_wrapper) -> dict:
+    """Pre-scan C# files to build a name-to-files mapping."""
+    name_to_files = {}
+    
+    for path in files:
+        try:
+            with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+                content = f.read()
+            
+            # Match class declarations
+            class_matches = re.finditer(
+                r'\b(?:public\s+|private\s+|protected\s+|internal\s+)?(?:static\s+)?(?:abstract\s+)?(?:sealed\s+)?(?:partial\s+)?class\s+(\w+)',
+                content
+            )
+            for match in class_matches:
+                class_name = match.group(1)
+                if class_name not in name_to_files:
+                    name_to_files[class_name] = []
+                name_to_files[class_name].append(str(path))
+            
+            # Match interface declarations
+            interface_matches = re.finditer(
+                r'\b(?:public\s+|private\s+|protected\s+|internal\s+)?(?:partial\s+)?interface\s+(\w+)',
+                content
+            )
+            for match in interface_matches:
+                interface_name = match.group(1)
+                if interface_name not in name_to_files:
+                    name_to_files[interface_name] = []
+                name_to_files[interface_name].append(str(path))
+            
+            # Match struct declarations
+            struct_matches = re.finditer(
+                r'\b(?:public\s+|private\s+|protected\s+|internal\s+)?(?:readonly\s+)?(?:partial\s+)?struct\s+(\w+)',
+                content
+            )
+            for match in struct_matches:
+                struct_name = match.group(1)
+                if struct_name not in name_to_files:
+                    name_to_files[struct_name] = []
+                name_to_files[struct_name].append(str(path))
+            
+            # Match record declarations
+            record_matches = re.finditer(
+                r'\b(?:public\s+|private\s+|protected\s+|internal\s+)?(?:sealed\s+)?record\s+(?:class\s+)?(\w+)',
+                content
+            )
+            for match in record_matches:
+                record_name = match.group(1)
+                if record_name not in name_to_files:
+                    name_to_files[record_name] = []
+                name_to_files[record_name].append(str(path))
+                
+        except Exception as e:
+            error_logger(f"Error pre-scanning C# file {path}: {e}")
+            
+    return name_to_files