codemap-csharp 0.1.0__tar.gz

codemap_csharp-0.1.0/.gitignore

@@ -0,0 +1,43 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Build artifacts
+build/
+dist/
+*.egg-info/
+*.egg
+.eggs/
+
+# Test / coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+.tox/
+.mypy_cache/
+.ruff_cache/
+.benchmarks/
+
+# Virtualenv
+.venv/
+venv/
+env/
+
+# uv / pdm lockfiles (commit uv.lock once we settle)
+# uv.lock
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# CodeMap own index when dogfooding
+.codemap/

codemap_csharp-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: codemap-csharp
+Version: 0.1.0
+Summary: C# language indexer plugin for CodeMap
+Project-URL: Homepage, https://github.com/qxbyte/codemap
+Author: CodeMap Contributors
+License: MIT
+Keywords: c-sharp,codemap,csharp,dotnet,indexer,tree-sitter
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: C#
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Requires-Dist: codemap-core<0.2,>=0.1.0
+Requires-Dist: tree-sitter-c-sharp>=0.23
+Requires-Dist: tree-sitter>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# codemap-csharp
+
+> A C# language indexer for [CodeMap](https://github.com/qxbyte/codemap),
+> shipped as an independent PyPI package.
+
+## What it captures
+
+Backed by `tree-sitter-c-sharp`:
+
+| AST node | Symbol kind |
+|---|---|
+| `namespace_declaration` (incl. `qualified_name`) | namespace prefix (recursed into) |
+| `class_declaration` | `class` |
+| `interface_declaration` | `class` (`extra.csharp_kind=interface`) |
+| `struct_declaration` | `class` (`extra.csharp_kind=struct`) |
+| `record_declaration` | `class` (`extra.csharp_kind=record`) |
+| `enum_declaration` | `class` (`extra.csharp_kind=enum`) |
+| `delegate_declaration` | `class` (`extra.csharp_kind=delegate`) |
+| `method_declaration` | `method` |
+| `property_declaration` | `field` (`extra.csharp_kind=property`) |
+| `field_declaration` → `variable_declarator` | `field` |
+| `enum_member_declaration` | `field` |
+
+Top-level statements (C# 9+) are not surfaced as named symbols.
+
+## Install
+
+```bash
+pip install codemap-csharp
+```
+
+## File patterns
+
+* `*.cs`, `*.csx`
+
+## Limits
+
+* File-scoped namespaces (``namespace App;``) and block-scoped namespaces
+  are both handled, but global usings are not emitted as symbols.
+* Partial classes are emitted as separate symbols per file — the index
+  layer does not currently merge them.
+
+## License
+
+MIT.

codemap_csharp-0.1.0/README.md

@@ -0,0 +1,45 @@
+# codemap-csharp
+
+> A C# language indexer for [CodeMap](https://github.com/qxbyte/codemap),
+> shipped as an independent PyPI package.
+
+## What it captures
+
+Backed by `tree-sitter-c-sharp`:
+
+| AST node | Symbol kind |
+|---|---|
+| `namespace_declaration` (incl. `qualified_name`) | namespace prefix (recursed into) |
+| `class_declaration` | `class` |
+| `interface_declaration` | `class` (`extra.csharp_kind=interface`) |
+| `struct_declaration` | `class` (`extra.csharp_kind=struct`) |
+| `record_declaration` | `class` (`extra.csharp_kind=record`) |
+| `enum_declaration` | `class` (`extra.csharp_kind=enum`) |
+| `delegate_declaration` | `class` (`extra.csharp_kind=delegate`) |
+| `method_declaration` | `method` |
+| `property_declaration` | `field` (`extra.csharp_kind=property`) |
+| `field_declaration` → `variable_declarator` | `field` |
+| `enum_member_declaration` | `field` |
+
+Top-level statements (C# 9+) are not surfaced as named symbols.
+
+## Install
+
+```bash
+pip install codemap-csharp
+```
+
+## File patterns
+
+* `*.cs`, `*.csx`
+
+## Limits
+
+* File-scoped namespaces (``namespace App;``) and block-scoped namespaces
+  are both handled, but global usings are not emitted as symbols.
+* Partial classes are emitted as separate symbols per file — the index
+  layer does not currently merge them.
+
+## License
+
+MIT.

codemap_csharp-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "codemap-csharp"
+version = "0.1.0"
+description = "C# language indexer plugin for CodeMap"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "CodeMap Contributors" }]
+keywords = ["codemap", "csharp", "c-sharp", "dotnet", "indexer", "tree-sitter"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: C#",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development",
+]
+dependencies = [
+    "codemap-core>=0.1.0,<0.2",
+    "tree-sitter>=0.25",
+    "tree-sitter-c-sharp>=0.23",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+
+[project.entry-points."codemap.indexers"]
+csharp = "codemap_csharp:CSharpIndexer"
+
+[project.urls]
+Homepage = "https://github.com/qxbyte/codemap"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/codemap_csharp"]

codemap_csharp-0.1.0/src/codemap_csharp/__init__.py

@@ -0,0 +1,8 @@
+"""C# indexer plugin for CodeMap."""
+
+from __future__ import annotations
+
+from codemap_csharp.indexer import CSharpIndexer
+
+__all__ = ["CSharpIndexer"]
+__version__ = "0.1.0"

codemap_csharp-0.1.0/src/codemap_csharp/indexer.py

@@ -0,0 +1,315 @@
+"""C# indexer built on tree-sitter-c-sharp.
+
+``namespace_declaration`` chains (including dotted ``A.B.C`` qualifiers)
+are decomposed into a stack of namespace descriptors that prefix each
+contained type's SymbolID.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+from typing import ClassVar
+
+import tree_sitter
+import tree_sitter_c_sharp
+
+from codemap.core.models import Diagnostic, Edge, IndexResult, Range, Symbol
+from codemap.core.symbol import Descriptor, DescriptorKind, SymbolID
+from codemap.indexers.base import IndexContext
+
+SCHEME = "scip-csharp"
+LANG = "csharp"
+
+_CS_LANG = tree_sitter.Language(tree_sitter_c_sharp.language())
+
+_TYPE_DECL_KINDS = {
+    "class_declaration": (None, "class"),
+    "interface_declaration": ("interface", "class"),
+    "struct_declaration": ("struct", "class"),
+    "record_declaration": ("record", "class"),
+    "enum_declaration": ("enum", "class"),
+    "delegate_declaration": ("delegate", "class"),
+}
+
+
+class CSharpIndexer:
+    name: ClassVar[str] = "csharp"
+    version: ClassVar[str] = "0.1.0"
+    file_patterns: ClassVar[list[str]] = ["*.cs", "*.csx"]
+    languages: ClassVar[list[str]] = [LANG]
+
+    def supports(self, path: Path) -> bool:
+        return path.suffix in {".cs", ".csx"}
+
+    def index_file(
+        self,
+        path: Path,
+        source: bytes,
+        ctx: IndexContext,
+    ) -> IndexResult:
+        try:
+            source.decode("utf-8")
+        except UnicodeDecodeError as exc:
+            return IndexResult(
+                diagnostics=[
+                    Diagnostic(
+                        severity="error",
+                        file=ctx.relative_path,
+                        code="CS002",
+                        message=f"not valid UTF-8: {exc}",
+                        producer=self.name,
+                    )
+                ]
+            )
+        parser = tree_sitter.Parser(_CS_LANG)
+        tree = parser.parse(source)
+        visitor = _Visitor(ctx.relative_path)
+        visitor.visit_root(tree.root_node)
+        diagnostics = list(visitor.diagnostics)
+        if tree.root_node.has_error:
+            diagnostics.append(
+                Diagnostic(
+                    severity="warning",
+                    file=ctx.relative_path,
+                    range=Range(start_line=1, end_line=1),
+                    code="CS001",
+                    message="tree-sitter reported parse errors; symbols may be incomplete",
+                    producer=self.name,
+                )
+            )
+        return IndexResult(
+            symbols=visitor.symbols,
+            edges=visitor.edges,
+            diagnostics=diagnostics,
+        )
+
+
+class _Visitor:
+    def __init__(self, relative_path: PurePosixPath) -> None:
+        self.relative_path = relative_path
+        self.symbols: list[Symbol] = []
+        self.edges: list[Edge] = []
+        self.diagnostics: list[Diagnostic] = []
+
+    def visit_root(self, root: tree_sitter.Node) -> None:
+        for child in root.children:
+            self._visit(child, scope=[])
+
+    def _visit(
+        self,
+        node: tree_sitter.Node,
+        *,
+        scope: list[Descriptor],
+    ) -> None:
+        kind = node.type
+        if kind == "namespace_declaration":
+            self._visit_namespace(node, scope=scope)
+        elif kind in _TYPE_DECL_KINDS:
+            csharp_kind, symbol_kind = _TYPE_DECL_KINDS[kind]
+            self._emit_type(
+                node,
+                scope=scope,
+                csharp_kind=csharp_kind,
+                symbol_kind=symbol_kind,
+            )
+        elif kind == "method_declaration":
+            self._emit_method(node, scope=scope)
+        elif kind == "property_declaration":
+            self._emit_property(node, scope=scope)
+        elif kind == "field_declaration":
+            self._emit_field_declaration(node, scope=scope)
+        elif kind == "enum_member_declaration":
+            self._emit_enum_member(node, scope=scope)
+
+    def _visit_namespace(
+        self,
+        node: tree_sitter.Node,
+        *,
+        scope: list[Descriptor],
+    ) -> None:
+        new_scope = list(scope)
+        for child in node.children:
+            if child.type == "identifier":
+                new_scope.append(Descriptor(name=_node_text(child), kind=DescriptorKind.NAMESPACE))
+            elif child.type == "qualified_name":
+                new_scope.extend(
+                    Descriptor(name=part, kind=DescriptorKind.NAMESPACE)
+                    for part in _qualified_name_parts(child)
+                )
+        body = _first_child(node, "declaration_list")
+        if body is None:
+            return
+        for child in body.children:
+            self._visit(child, scope=new_scope)
+
+    def _emit_type(
+        self,
+        node: tree_sitter.Node,
+        *,
+        scope: list[Descriptor],
+        csharp_kind: str | None,
+        symbol_kind: str,
+    ) -> None:
+        name = _first_child_text(node, "identifier")
+        if name is None:
+            return
+        type_desc = Descriptor(name=name, kind=DescriptorKind.TYPE)
+        descriptors = [*list(scope), type_desc]
+        extra: dict[str, str] = {}
+        if csharp_kind is not None:
+            extra["csharp_kind"] = csharp_kind
+        self.symbols.append(
+            Symbol(
+                id=self._make_id(descriptors),
+                kind=symbol_kind,
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                extra=extra,
+            )
+        )
+        # Recurse into nested members.
+        body = _first_child(node, "declaration_list") or _first_child(
+            node, "enum_member_declaration_list"
+        )
+        if body is None:
+            return
+        for child in body.children:
+            self._visit(child, scope=descriptors)
+
+    def _emit_method(
+        self,
+        node: tree_sitter.Node,
+        *,
+        scope: list[Descriptor],
+    ) -> None:
+        name = _first_child_text(node, "identifier")
+        if name is None:
+            return
+        self.symbols.append(
+            Symbol(
+                id=self._make_id([*list(scope), Descriptor(name=name, kind=DescriptorKind.METHOD)]),
+                kind="method",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                signature=f"{name}()",
+            )
+        )
+
+    def _emit_property(
+        self,
+        node: tree_sitter.Node,
+        *,
+        scope: list[Descriptor],
+    ) -> None:
+        name = _first_child_text(node, "identifier")
+        if name is None:
+            return
+        self.symbols.append(
+            Symbol(
+                id=self._make_id([*list(scope), Descriptor(name=name, kind=DescriptorKind.TERM)]),
+                kind="field",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                extra={"csharp_kind": "property"},
+            )
+        )
+
+    def _emit_field_declaration(
+        self,
+        node: tree_sitter.Node,
+        *,
+        scope: list[Descriptor],
+    ) -> None:
+        var_decl = _first_child(node, "variable_declaration")
+        if var_decl is None:
+            return
+        for child in var_decl.children:
+            if child.type == "variable_declarator":
+                name = _first_child_text(child, "identifier")
+                if name is None:
+                    continue
+                self.symbols.append(
+                    Symbol(
+                        id=self._make_id(
+                            [*list(scope), Descriptor(name=name, kind=DescriptorKind.TERM)]
+                        ),
+                        kind="field",
+                        language=LANG,
+                        file=self.relative_path,
+                        range=_node_range(node),
+                    )
+                )
+
+    def _emit_enum_member(
+        self,
+        node: tree_sitter.Node,
+        *,
+        scope: list[Descriptor],
+    ) -> None:
+        name = _first_child_text(node, "identifier")
+        if name is None:
+            return
+        self.symbols.append(
+            Symbol(
+                id=self._make_id([*list(scope), Descriptor(name=name, kind=DescriptorKind.TERM)]),
+                kind="field",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                extra={"csharp_kind": "enum_member"},
+            )
+        )
+
+    def _make_id(self, descriptors: list[Descriptor]) -> SymbolID:
+        full = list(_path_namespaces(self.relative_path))
+        full.extend(descriptors)
+        return SymbolID(scheme=SCHEME, descriptors=tuple(full))
+
+
+# ---------------------------------------------------------------------------
+# Pure helpers
+# ---------------------------------------------------------------------------
+
+
+def _path_namespaces(path: PurePosixPath) -> list[Descriptor]:
+    return [Descriptor(name=part, kind=DescriptorKind.NAMESPACE) for part in path.parts]
+
+
+def _node_range(node: tree_sitter.Node) -> Range:
+    sr, sc = node.start_point
+    er, ec = node.end_point
+    return Range(
+        start_line=sr + 1,
+        start_col=sc,
+        end_line=max(er + 1, sr + 1),
+        end_col=ec,
+    )
+
+
+def _node_text(node: tree_sitter.Node) -> str:
+    return node.text.decode("utf-8") if node.text is not None else ""
+
+
+def _first_child(node: tree_sitter.Node, kind: str) -> tree_sitter.Node | None:
+    for child in node.children:
+        if child.type == kind:
+            return child
+    return None
+
+
+def _first_child_text(node: tree_sitter.Node, kind: str) -> str | None:
+    found = _first_child(node, kind)
+    return _node_text(found) if found is not None else None
+
+
+def _qualified_name_parts(node: tree_sitter.Node) -> list[str]:
+    parts: list[str] = []
+    for child in node.children:
+        if child.type == "identifier":
+            parts.append(_node_text(child))
+        elif child.type == "qualified_name":
+            parts.extend(_qualified_name_parts(child))
+    return parts

codemap_csharp-0.1.0/tests/test_indexer.py

@@ -0,0 +1,181 @@
+"""Unit tests for the C# indexer plugin."""
+
+from __future__ import annotations
+
+import textwrap
+from pathlib import Path, PurePosixPath
+
+from codemap_csharp import CSharpIndexer
+from codemap_csharp.indexer import SCHEME
+
+from codemap.core.models import IndexResult
+from codemap.indexers.base import IndexContext
+
+
+def _index(source: str, *, path: str = "src/Lib.cs") -> IndexResult:
+    code = textwrap.dedent(source).lstrip("\n")
+    return CSharpIndexer().index_file(
+        Path(path),
+        code.encode("utf-8"),
+        IndexContext(
+            project_root=Path("/tmp/proj"),
+            relative_path=PurePosixPath(path),
+            language="csharp",
+        ),
+    )
+
+
+def test_indexer_metadata() -> None:
+    ix = CSharpIndexer()
+    assert ix.name == "csharp"
+    assert ix.languages == ["csharp"]
+    assert ix.supports(Path("a.cs"))
+    assert ix.supports(Path("a.csx"))
+    assert not ix.supports(Path("a.py"))
+
+
+def test_scheme_is_consistent() -> None:
+    r = _index("class C {}")
+    for s in r.symbols:
+        assert str(s.id).startswith(f"{SCHEME} ")
+
+
+def test_simple_class_with_method_field_property() -> None:
+    r = _index(
+        """
+        class Foo {
+            public int Counter;
+            public string Name { get; set; }
+            public void Bar() {}
+        }
+        """
+    )
+    classes = [s for s in r.symbols if s.kind == "class"]
+    methods = [s for s in r.symbols if s.kind == "method"]
+    fields = [s for s in r.symbols if s.kind == "field"]
+    assert {c.id.descriptors[-1].name for c in classes} == {"Foo"}
+    assert {m.id.descriptors[-1].name for m in methods} == {"Bar"}
+    field_names = {f.id.descriptors[-1].name for f in fields}
+    assert {"Counter", "Name"} <= field_names
+
+
+def test_interface_struct_record_enum_delegate() -> None:
+    r = _index(
+        """
+        public interface IThing { void Do(); }
+        public struct Point { public int X; }
+        public record Person(string Name);
+        public enum Color { Red, Green }
+        public delegate void Handler();
+        """
+    )
+    by_kind: dict[str, str] = {}
+    for s in r.symbols:
+        if s.kind == "class":
+            by_kind[s.id.descriptors[-1].name] = s.extra.get("csharp_kind", "class")
+    assert by_kind["IThing"] == "interface"
+    assert by_kind["Point"] == "struct"
+    assert by_kind["Person"] == "record"
+    assert by_kind["Color"] == "enum"
+    assert by_kind["Handler"] == "delegate"
+
+
+def test_enum_members_emitted_as_fields() -> None:
+    r = _index("enum Color { Red, Green, Blue }")
+    fields = [s for s in r.symbols if s.kind == "field"]
+    assert {f.id.descriptors[-1].name for f in fields} == {"Red", "Green", "Blue"}
+
+
+def test_block_namespace_prefixes_descriptors() -> None:
+    r = _index(
+        """
+        namespace App {
+            class Foo {}
+        }
+        """
+    )
+    foo = next(s for s in r.symbols if s.kind == "class")
+    names = [d.name for d in foo.id.descriptors]
+    assert "App" in names
+    assert "Foo" in names
+
+
+def test_qualified_namespace_is_split() -> None:
+    r = _index(
+        """
+        namespace App.Core.Util {
+            class Helper {}
+        }
+        """
+    )
+    helper = next(s for s in r.symbols if s.kind == "class")
+    names = [d.name for d in helper.id.descriptors]
+    # The three dotted components should each appear as a NAMESPACE descriptor.
+    assert names.index("App") < names.index("Core") < names.index("Util") < names.index("Helper")
+
+
+def test_nested_class_descriptors() -> None:
+    r = _index(
+        """
+        class Outer {
+            class Inner {
+                public int Field;
+            }
+        }
+        """
+    )
+    inner = next(s for s in r.symbols if s.kind == "class" and s.id.descriptors[-1].name == "Inner")
+    names = [d.name for d in inner.id.descriptors]
+    assert names.index("Outer") < names.index("Inner")
+
+
+def test_multiple_field_declarators_on_one_line() -> None:
+    r = _index(
+        """
+        class C {
+            public int A, B, Cee;
+        }
+        """
+    )
+    fields = [s for s in r.symbols if s.kind == "field"]
+    assert {f.id.descriptors[-1].name for f in fields} == {"A", "B", "Cee"}
+
+
+def test_property_marked_with_kind() -> None:
+    r = _index(
+        """
+        class C {
+            public string Name { get; set; }
+        }
+        """
+    )
+    name_prop = next(
+        s for s in r.symbols if s.kind == "field" and s.id.descriptors[-1].name == "Name"
+    )
+    assert name_prop.extra.get("csharp_kind") == "property"
+
+
+def test_symbol_id_uses_path_namespaces() -> None:
+    r = _index("class C {}", path="src/Util/Helpers.cs")
+    cls = next(s for s in r.symbols if s.kind == "class")
+    assert str(cls.id) == "scip-csharp . . . src/Util/Helpers.cs/C#"
+
+
+def test_empty_file_yields_no_symbols() -> None:
+    r = _index("")
+    assert r.symbols == []
+
+
+def test_invalid_utf8_yields_diagnostic() -> None:
+    ix = CSharpIndexer()
+    r = ix.index_file(
+        Path("Bad.cs"),
+        b"\xff\xfe class",
+        IndexContext(
+            project_root=Path("/tmp/proj"),
+            relative_path=PurePosixPath("Bad.cs"),
+            language="csharp",
+        ),
+    )
+    assert r.symbols == []
+    assert r.diagnostics[0].code == "CS002"