codemap-c 0.1.0a1__tar.gz

codemap_c-0.1.0a1/.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_c-0.1.0a1/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: codemap-c
+Version: 0.1.0a1
+Summary: C language indexer plugin for CodeMap
+Project-URL: Homepage, https://github.com/qxbyte/codemap
+Author: CodeMap Contributors
+License: MIT
+Keywords: c,codemap,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.0a1
+Requires-Dist: tree-sitter-c>=0.24
+Requires-Dist: tree-sitter>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# codemap-c
+
+> 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`:
+
+| AST node | Symbol kind |
+|---|---|
+| `function_definition` | `function` |
+| `struct_specifier` (named, with body) | `class` (`extra.c_kind=struct`) |
+| `union_specifier` (named, with body) | `class` (`extra.c_kind=union`) |
+| `enum_specifier` (named) | `class` (`extra.c_kind=enum`) |
+| `type_definition` (`typedef`) | `class` (`extra.c_kind=typedef`) |
+| `preproc_def` (`#define X ...`) | `variable` (`extra.c_kind=macro`) |
+| Top-level `declaration` with initializer | `variable` |
+| `field_declaration` inside a struct/union body | `field` (attached to the parent) |
+
+Function bodies are not walked for inner declarations — locals are not
+script-level interface.
+
+## Install
+
+```bash
+pip install "git+https://github.com/qxbyte/codemap.git#subdirectory=plugins/codemap-c"
+```
+
+## File patterns
+
+* `*.c`, `*.h`
+
+## Limits
+
+* Preprocessor conditionals (`#ifdef`/`#if`) parse but no branch selection
+  is performed — both arms contribute symbols.
+* Function declarations (prototypes) are not emitted; only definitions.
+* Forward struct declarations without a body are skipped.
+
+## License
+
+MIT.

codemap_c-0.1.0a1/README.md

@@ -0,0 +1,43 @@
+# codemap-c
+
+> 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`:
+
+| AST node | Symbol kind |
+|---|---|
+| `function_definition` | `function` |
+| `struct_specifier` (named, with body) | `class` (`extra.c_kind=struct`) |
+| `union_specifier` (named, with body) | `class` (`extra.c_kind=union`) |
+| `enum_specifier` (named) | `class` (`extra.c_kind=enum`) |
+| `type_definition` (`typedef`) | `class` (`extra.c_kind=typedef`) |
+| `preproc_def` (`#define X ...`) | `variable` (`extra.c_kind=macro`) |
+| Top-level `declaration` with initializer | `variable` |
+| `field_declaration` inside a struct/union body | `field` (attached to the parent) |
+
+Function bodies are not walked for inner declarations — locals are not
+script-level interface.
+
+## Install
+
+```bash
+pip install "git+https://github.com/qxbyte/codemap.git#subdirectory=plugins/codemap-c"
+```
+
+## File patterns
+
+* `*.c`, `*.h`
+
+## Limits
+
+* Preprocessor conditionals (`#ifdef`/`#if`) parse but no branch selection
+  is performed — both arms contribute symbols.
+* Function declarations (prototypes) are not emitted; only definitions.
+* Forward struct declarations without a body are skipped.
+
+## License
+
+MIT.

codemap_c-0.1.0a1/pyproject.toml

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

codemap_c-0.1.0a1/src/codemap_c/__init__.py

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

codemap_c-0.1.0a1/src/codemap_c/indexer.py

@@ -0,0 +1,323 @@
+"""C indexer built on tree-sitter-c.
+
+Top-level declarations only (function bodies are not walked for inner
+state). Captured node kinds:
+
+* ``function_definition``                       → ``function``
+* ``struct_specifier`` / ``union_specifier``     → ``class`` (with body)
+* ``enum_specifier``                             → ``class``
+* ``type_definition`` (``typedef``)              → ``class``
+* ``preproc_def`` / ``preproc_function_def``     → ``variable`` (macro)
+* top-level ``declaration`` with initializer     → ``variable``
+* ``field_declaration`` inside struct/union body → ``field``
+"""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+from typing import ClassVar
+
+import tree_sitter
+import tree_sitter_c
+
+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-c"
+LANG = "c"
+
+_C_LANG = tree_sitter.Language(tree_sitter_c.language())
+
+
+class CIndexer:
+    name: ClassVar[str] = "c"
+    version: ClassVar[str] = "0.1.0"
+    file_patterns: ClassVar[list[str]] = ["*.c", "*.h"]
+    languages: ClassVar[list[str]] = [LANG]
+
+    def supports(self, path: Path) -> bool:
+        return path.suffix in {".c", ".h"}
+
+    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="C002",
+                        message=f"not valid UTF-8: {exc}",
+                        producer=self.name,
+                    )
+                ]
+            )
+        parser = tree_sitter.Parser(_C_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="C001",
+                    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_top_level(child)
+
+    def _visit_top_level(self, node: tree_sitter.Node) -> None:
+        kind = node.type
+        if kind == "function_definition":
+            self._emit_function(node)
+        elif kind == "preproc_def":
+            self._emit_macro(node, function_like=False)
+        elif kind == "preproc_function_def":
+            self._emit_macro(node, function_like=True)
+        elif kind == "type_definition":
+            self._emit_typedef(node)
+        elif kind == "struct_specifier":
+            self._emit_record(node, c_kind="struct")
+        elif kind == "union_specifier":
+            self._emit_record(node, c_kind="union")
+        elif kind == "enum_specifier":
+            self._emit_enum(node)
+        elif kind == "declaration":
+            self._emit_declaration(node)
+
+    def _emit_function(self, node: tree_sitter.Node) -> None:
+        name = _function_declarator_name(node)
+        if name is None:
+            return
+        sid = self._make_id([Descriptor(name=name, kind=DescriptorKind.METHOD)])
+        self.symbols.append(
+            Symbol(
+                id=sid,
+                kind="function",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                signature=f"{name}()",
+            )
+        )
+
+    def _emit_macro(self, node: tree_sitter.Node, *, function_like: bool) -> None:
+        name = _first_child_text(node, "identifier")
+        if name is None:
+            return
+        sid = self._make_id([Descriptor(name=name, kind=DescriptorKind.TERM)])
+        extra = {"c_kind": "macro_fn" if function_like else "macro"}
+        self.symbols.append(
+            Symbol(
+                id=sid,
+                kind="variable",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                extra=extra,
+            )
+        )
+
+    def _emit_typedef(self, node: tree_sitter.Node) -> None:
+        # The aliased name is the last type_identifier child of the
+        # type_definition.
+        name: str | None = None
+        for child in node.children:
+            if child.type == "type_identifier":
+                name = _node_text(child)
+        if name is None:
+            return
+        sid = self._make_id([Descriptor(name=name, kind=DescriptorKind.TYPE)])
+        self.symbols.append(
+            Symbol(
+                id=sid,
+                kind="class",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                extra={"c_kind": "typedef"},
+            )
+        )
+
+    def _emit_record(self, node: tree_sitter.Node, *, c_kind: str) -> None:
+        # Skip anonymous structs / forward declarations without a body.
+        name = _first_child_text(node, "type_identifier")
+        body = _first_child(node, "field_declaration_list")
+        if name is None or body is None:
+            return
+        record_desc = Descriptor(name=name, kind=DescriptorKind.TYPE)
+        sid = self._make_id([record_desc])
+        self.symbols.append(
+            Symbol(
+                id=sid,
+                kind="class",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                extra={"c_kind": c_kind},
+            )
+        )
+        for child in body.children:
+            if child.type == "field_declaration":
+                self._emit_field(child, parent=record_desc)
+
+    def _emit_enum(self, node: tree_sitter.Node) -> None:
+        name = _first_child_text(node, "type_identifier")
+        if name is None:
+            return
+        enum_desc = Descriptor(name=name, kind=DescriptorKind.TYPE)
+        sid = self._make_id([enum_desc])
+        self.symbols.append(
+            Symbol(
+                id=sid,
+                kind="class",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                extra={"c_kind": "enum"},
+            )
+        )
+        body = _first_child(node, "enumerator_list")
+        if body is None:
+            return
+        for child in body.children:
+            if child.type == "enumerator":
+                enum_name = _first_child_text(child, "identifier")
+                if enum_name is None:
+                    continue
+                self.symbols.append(
+                    Symbol(
+                        id=self._make_id(
+                            [
+                                enum_desc,
+                                Descriptor(name=enum_name, kind=DescriptorKind.TERM),
+                            ]
+                        ),
+                        kind="field",
+                        language=LANG,
+                        file=self.relative_path,
+                        range=_node_range(child),
+                        extra={"c_kind": "enumerator"},
+                    )
+                )
+
+    def _emit_field(
+        self,
+        node: tree_sitter.Node,
+        *,
+        parent: Descriptor,
+    ) -> None:
+        name = _first_child_text(node, "field_identifier")
+        if name is None:
+            return
+        self.symbols.append(
+            Symbol(
+                id=self._make_id([parent, Descriptor(name=name, kind=DescriptorKind.TERM)]),
+                kind="field",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+            )
+        )
+
+    def _emit_declaration(self, node: tree_sitter.Node) -> None:
+        # Only emit when there's an init_declarator (i.e. a definition with
+        # a value), not a bare extern prototype.
+        for child in node.children:
+            if child.type == "init_declarator":
+                name = _first_child_text(child, "identifier")
+                if name is None:
+                    continue
+                self.symbols.append(
+                    Symbol(
+                        id=self._make_id([Descriptor(name=name, kind=DescriptorKind.TERM)]),
+                        kind="variable",
+                        language=LANG,
+                        file=self.relative_path,
+                        range=_node_range(node),
+                    )
+                )
+
+    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 _function_declarator_name(node: tree_sitter.Node) -> str | None:
+    """``int add(int, int) { ... }`` → ``add``. The function_declarator may
+    be wrapped in pointers (``int *foo(...)``), so unwrap recursively.
+    """
+    declarator = _first_child(node, "function_declarator")
+    if declarator is None:
+        # Walk through pointer_declarator wrappers.
+        for child in node.children:
+            if child.type in {"pointer_declarator", "parenthesized_declarator"}:
+                name = _function_declarator_name(child)
+                if name is not None:
+                    return name
+        return None
+    return _first_child_text(declarator, "identifier")

codemap_c-0.1.0a1/tests/test_indexer.py

@@ -0,0 +1,180 @@
+"""Unit tests for the C indexer plugin."""
+
+from __future__ import annotations
+
+import textwrap
+from pathlib import Path, PurePosixPath
+
+from codemap_c import CIndexer
+from codemap_c.indexer import SCHEME
+
+from codemap.core.models import IndexResult
+from codemap.indexers.base import IndexContext
+
+
+def _index(source: str, *, path: str = "src/lib.c") -> IndexResult:
+    code = textwrap.dedent(source).lstrip("\n")
+    return CIndexer().index_file(
+        Path(path),
+        code.encode("utf-8"),
+        IndexContext(
+            project_root=Path("/tmp/proj"),
+            relative_path=PurePosixPath(path),
+            language="c",
+        ),
+    )
+
+
+def test_indexer_metadata() -> None:
+    ix = CIndexer()
+    assert ix.name == "c"
+    assert ix.languages == ["c"]
+    assert ix.supports(Path("a.c"))
+    assert ix.supports(Path("a.h"))
+    assert not ix.supports(Path("a.py"))
+
+
+def test_scheme_is_consistent() -> None:
+    r = _index("int x = 1;\nint f(void) { return 0; }")
+    for s in r.symbols:
+        assert str(s.id).startswith(f"{SCHEME} ")
+
+
+def test_function_definition() -> None:
+    r = _index("int add(int a, int b) { return a + b; }")
+    funcs = [s for s in r.symbols if s.kind == "function"]
+    assert len(funcs) == 1
+    assert funcs[0].id.descriptors[-1].name == "add"
+    assert funcs[0].signature == "add()"
+
+
+def test_struct_with_fields() -> None:
+    r = _index(
+        """
+        struct Point {
+            int x;
+            int y;
+        };
+        """
+    )
+    classes = [s for s in r.symbols if s.kind == "class"]
+    fields = [s for s in r.symbols if s.kind == "field"]
+    assert len(classes) == 1
+    assert classes[0].extra["c_kind"] == "struct"
+    assert {f.id.descriptors[-1].name for f in fields} == {"x", "y"}
+
+
+def test_union_with_fields() -> None:
+    r = _index(
+        """
+        union U {
+            int i;
+            float f;
+        };
+        """
+    )
+    classes = [s for s in r.symbols if s.kind == "class"]
+    assert len(classes) == 1
+    assert classes[0].extra["c_kind"] == "union"
+    assert len([s for s in r.symbols if s.kind == "field"]) == 2
+
+
+def test_enum_with_enumerators() -> None:
+    r = _index("enum Color { RED, GREEN, BLUE };")
+    classes = [s for s in r.symbols if s.kind == "class"]
+    fields = [s for s in r.symbols if s.kind == "field"]
+    assert classes[0].extra["c_kind"] == "enum"
+    assert {f.id.descriptors[-1].name for f in fields} == {"RED", "GREEN", "BLUE"}
+
+
+def test_typedef_int_alias() -> None:
+    r = _index("typedef int MyInt;")
+    typedefs = [s for s in r.symbols if s.kind == "class"]
+    assert len(typedefs) == 1
+    assert typedefs[0].extra["c_kind"] == "typedef"
+    assert typedefs[0].id.descriptors[-1].name == "MyInt"
+
+
+def test_object_macro() -> None:
+    r = _index("#define MAX 10")
+    macros = [s for s in r.symbols if s.kind == "variable"]
+    assert len(macros) == 1
+    assert macros[0].extra["c_kind"] == "macro"
+    assert macros[0].id.descriptors[-1].name == "MAX"
+
+
+def test_function_like_macro() -> None:
+    r = _index("#define SQUARE(x) ((x)*(x))")
+    macros = [s for s in r.symbols if s.kind == "variable"]
+    assert macros[0].extra["c_kind"] == "macro_fn"
+    assert macros[0].id.descriptors[-1].name == "SQUARE"
+
+
+def test_top_level_variable_with_initializer() -> None:
+    r = _index("static int counter = 0;")
+    vars_ = [s for s in r.symbols if s.kind == "variable"]
+    assert len(vars_) == 1
+    assert vars_[0].id.descriptors[-1].name == "counter"
+
+
+def test_function_bodies_are_opaque() -> None:
+    """Locals declared inside a function body must not surface."""
+    r = _index(
+        """
+        int compute(void) {
+            int local_a = 1;
+            int local_b = 2;
+            return local_a + local_b;
+        }
+        """
+    )
+    assert {s.id.descriptors[-1].name for s in r.symbols} == {"compute"}
+
+
+def test_symbol_id_uses_path_namespaces() -> None:
+    r = _index("int x = 1;", path="src/util/math.c")
+    var = next(s for s in r.symbols if s.kind == "variable")
+    assert str(var.id) == "scip-c . . . src/util/math.c/x."
+
+
+def test_empty_file_yields_no_symbols() -> None:
+    r = _index("")
+    assert r.symbols == []
+
+
+def test_invalid_utf8_yields_diagnostic() -> None:
+    ix = CIndexer()
+    r = ix.index_file(
+        Path("bad.c"),
+        b"\xff\xfe int",
+        IndexContext(
+            project_root=Path("/tmp/proj"),
+            relative_path=PurePosixPath("bad.c"),
+            language="c",
+        ),
+    )
+    assert r.symbols == []
+    assert r.diagnostics[0].code == "C002"
+
+
+def test_realistic_translation_unit() -> None:
+    r = _index(
+        """
+        #include <stdio.h>
+        #define MAX 100
+        typedef struct { int x; } Box;
+        struct Inner { int v; };
+        enum Mode { ON, OFF };
+        static int counter = 0;
+        int process(int n) { return n + counter; }
+        """
+    )
+    by_kind: dict[str, set[str]] = {}
+    for s in r.symbols:
+        by_kind.setdefault(s.kind, set()).add(s.id.descriptors[-1].name)
+    assert "process" in by_kind["function"]
+    assert {"MAX", "counter"} <= by_kind["variable"]
+    assert {"Box", "Inner", "Mode"} <= by_kind["class"]
+    # Fields inside anonymous struct under a typedef are not addressable
+    # by C name scoping; only named-struct fields surface.
+    assert {"v", "ON", "OFF"} <= by_kind["field"]