rbtr-lang-cpp 2026.7.0.dev0__py3-none-any.whl

rbtr_lang_cpp/__init__.py

@@ -0,0 +1 @@
+"""C++ language plugin package."""

rbtr_lang_cpp/cpp.scm

@@ -0,0 +1,106 @@
+; Top-level comments (C++ uses one `comment` type for `//` and `/* */`).
+(comment) @comment
+
+(function_definition
+  declarator: (function_declarator
+    declarator: (identifier) @_fn_name)) @function
+
+(function_definition
+  declarator: (function_declarator
+    declarator: (field_identifier) @_fn_name)) @function
+
+(function_definition
+  declarator: (function_declarator
+    declarator: (operator_name) @_fn_name)) @function
+
+(field_declaration
+  declarator: (function_declarator
+    declarator: (field_identifier) @_method_name)) @method
+
+(field_declaration_list
+  (declaration
+    declarator: (function_declarator
+      declarator: (identifier) @_method_name)) @method)
+
+(preproc_include
+  path: (system_lib_string) @_import_module) @import
+
+(preproc_include
+  path: (string_literal) @_import_module) @import
+
+(preproc_function_def
+  name: (identifier) @_fn_name) @function
+
+(preproc_def
+  name: (identifier) @_var_name) @variable
+
+(class_specifier
+  name: (type_identifier) @_cls_name
+  body: (field_declaration_list)) @class
+
+(struct_specifier
+  name: (type_identifier) @_cls_name
+  body: (field_declaration_list)) @class
+
+(union_specifier
+  name: (type_identifier) @_cls_name
+  body: (field_declaration_list)) @class
+
+(enum_specifier
+  name: (type_identifier) @_cls_name
+  body: (enumerator_list)) @class
+
+(alias_declaration
+  name: (type_identifier) @_cls_name) @class
+
+(namespace_definition
+  name: (namespace_identifier) @_cls_name) @class
+
+(concept_definition
+  name: (identifier) @_cls_name) @class
+
+(translation_unit
+  (declaration
+    declarator: (function_declarator
+      declarator: (identifier) @_fn_name)) @function)
+
+(namespace_definition
+  body: (declaration_list
+    (declaration
+      declarator: (function_declarator
+        declarator: (identifier) @_fn_name)) @function))
+
+(translation_unit
+  (declaration
+    declarator: (init_declarator
+      declarator: (identifier) @_var_name)) @variable)
+
+(translation_unit
+  (declaration
+    declarator: (pointer_declarator
+      declarator: (identifier) @_var_name)) @variable)
+
+(translation_unit
+  (declaration
+    declarator: (init_declarator
+      declarator: (pointer_declarator
+        declarator: (identifier) @_var_name))) @variable)
+
+(namespace_definition
+  body: (declaration_list
+    (declaration
+      declarator: (init_declarator
+        declarator: (identifier) @_var_name)) @variable))
+
+(namespace_definition
+  body: (declaration_list
+    (declaration
+      declarator: (pointer_declarator
+        declarator: (identifier) @_var_name)) @variable))
+
+(namespace_definition
+  body: (declaration_list
+    (declaration
+      declarator: (init_declarator
+        declarator: (pointer_declarator
+          declarator: (identifier) @_var_name))) @variable))

rbtr_lang_cpp/plugin.py

@@ -0,0 +1,43 @@
+"""C++ language plugin.
+
+Provides symbol extraction (functions, prototypes, classes, structs,
+unions, enums, type aliases, namespaces, methods including operator
+overloads, namespace/global variables, and function/object-like
+macros) and include directive capture.  Namespaces are both a symbol
+(class) and a naming scope.
+
+Extracted chunks::
+
+    void greet() {}                 → function "greet", scope ""
+    class Shape {};                 → class "Shape", scope ""
+    struct Point { ... };           → class "Point", scope ""
+    class Foo {
+      void bar() {}                 → method "bar", scope "Foo"
+    };
+
+    #include <iostream>
+        → import, metadata {module: "iostream"}
+"""
+
+from __future__ import annotations
+
+from rbtr.languages.registration import LanguageRegistration, QueryExtraction, load_query
+
+# ── Query ────────────────────────────────────────────────────────────
+
+
+# ── Plugin ───────────────────────────────────────────────────────────
+
+
+cpp = LanguageRegistration(
+    id="cpp",
+    extensions=frozenset({".cpp", ".cc", ".cxx", ".hpp", ".hxx"}),
+    grammar_module="tree_sitter_cpp",
+    extraction=QueryExtraction(
+        query=load_query(__package__, "cpp"),
+        scope_types=frozenset({"class_specifier", "struct_specifier", "namespace_definition"}),
+        class_scope_types=frozenset({"class_specifier", "struct_specifier"}),
+    ),
+    source_roots=("", "include", "src"),
+    extraction_serial=6,
+)

rbtr_lang_cpp/tests/__snapshots__/test_samples/test_edges_match_snapshot.json

@@ -0,0 +1,7 @@
+[
+  "cpp.cpp::#include \"greeter.hpp\" -> greeter.hpp::Greeting [imports]",
+  "cpp.cpp::#include \"greeter.hpp\" -> greeter.hpp::Greeting [imports]",
+  "cpp.cpp::#include \"greeter.hpp\" -> greeter.hpp::greet [imports]",
+  "cpp.cpp::#include \"greeter.hpp\" -> greeter.hpp::render [imports]",
+  "cpp.cpp::#include \"greeter.hpp\" -> greeter.hpp::withDefault [imports]"
+]

rbtr_lang_cpp/tests/__snapshots__/test_samples/test_extraction_matches_snapshot.json

@@ -0,0 +1,488 @@
+[
+  {
+    "id": "30717ce6f7a37685",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "cpp",
+    "content": "// Greeter — format greetings for named recipients.\n//\n// The C++ plugin extracts free functions, prototypes, classes/structs/\n// unions, type aliases, namespaces (as classes and scopes), member\n// functions and operator overloads (as methods), namespace/global\n// variables (including pointer globals), macros, and #include imports.",
+    "line_start": 1,
+    "line_end": 6,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "b9a294f43e158d5e",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "import",
+    "name": "#include <string>",
+    "scope": "",
+    "language": "cpp",
+    "content": "#include <string>\n",
+    "line_start": 8,
+    "line_end": 9,
+    "metadata": {
+      "module": "string",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "e67c80769188dd11",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "import",
+    "name": "#include \"greeter.hpp\"",
+    "scope": "",
+    "language": "cpp",
+    "content": "#include \"greeter.hpp\"\n",
+    "line_start": 10,
+    "line_end": 11,
+    "metadata": {
+      "module": "greeter.hpp",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "2f6bcc64c3714d92",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "variable",
+    "name": "GREET_VERSION",
+    "scope": "",
+    "language": "cpp",
+    "content": "#define GREET_VERSION 2\n",
+    "line_start": 12,
+    "line_end": 13,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "8ba3d658ff2ec7c6",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "variable",
+    "name": "kAppName",
+    "scope": "",
+    "language": "cpp",
+    "content": "const char *kAppName = \"greeter\";",
+    "line_start": 14,
+    "line_end": 14,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "4eed4993fc15787d",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "cpp",
+    "content": "// trailing comment: its own chunk",
+    "line_start": 14,
+    "line_end": 14,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "43d1546e4f810260",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "cpp",
+    "content": "// Standalone note, separated by blank lines from any definition.\n// Second line of the same block.",
+    "line_start": 16,
+    "line_end": 17,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "b381fa11b53526df",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "class",
+    "name": "greet",
+    "scope": "",
+    "language": "cpp",
+    "content": "namespace greet {\n\nconst std::string DEFAULT_PREFIX = \"Hello\";\n\n// A short alias for a recipient name.\nusing Name = std::string;\n\n// Anything convertible to a std::string can name a recipient.\ntemplate <typename T>\nconcept Nameable = std::convertible_to<T, std::string>;\n\n// A tagged greeting payload.\nunion Payload {\n    int code;\n    const char *text;\n};\n\n// Build a greeter with the default prefix (declared here).\nGreeter make_default();\n\n// A greeter holding a prefix.\nclass Greeter {\n   public:\n    explicit Greeter(std::string prefix) : prefix_(std::move(prefix)) {}\n\n    // Greet a single recipient.\n    std::string greet(const std::string &name) const {\n        return prefix_ + \", \" + name;\n    }\n\n    // Two greeters are equal when their prefixes match.\n    bool operator==(const Greeter &other) const {\n        return prefix_ == other.prefix_;\n    }\n\n   private:\n    std::string prefix_;\n};\n\n// Format a greeting using a greeter.\nstd::string format_greeting(const Greeter &g, const std::string &name) {\n    return g.greet(name);\n}\n\n}",
+    "line_start": 19,
+    "line_end": 63,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "59f56ee2ad81de8a",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "variable",
+    "name": "DEFAULT_PREFIX",
+    "scope": "greet",
+    "language": "cpp",
+    "content": "const std::string DEFAULT_PREFIX = \"Hello\";",
+    "line_start": 21,
+    "line_end": 21,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "bcdb6a9bb1ac1e73",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "class",
+    "name": "Name",
+    "scope": "greet",
+    "language": "cpp",
+    "content": "// A short alias for a recipient name.\nusing Name = std::string;",
+    "line_start": 23,
+    "line_end": 24,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "a23a15e987dc9b6c",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "class",
+    "name": "Nameable",
+    "scope": "greet",
+    "language": "cpp",
+    "content": "concept Nameable = std::convertible_to<T, std::string>;",
+    "line_start": 28,
+    "line_end": 28,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "b089f7380dbf0746",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "class",
+    "name": "Payload",
+    "scope": "greet",
+    "language": "cpp",
+    "content": "// A tagged greeting payload.\nunion Payload {\n    int code;\n    const char *text;\n}",
+    "line_start": 30,
+    "line_end": 34,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "e74269deae2ae442",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "function",
+    "name": "make_default",
+    "scope": "greet",
+    "language": "cpp",
+    "content": "// Build a greeter with the default prefix (declared here).\nGreeter make_default();",
+    "line_start": 36,
+    "line_end": 37,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "e8f130340606bc1b",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "class",
+    "name": "Greeter",
+    "scope": "greet",
+    "language": "cpp",
+    "content": "// A greeter holding a prefix.\nclass Greeter {\n   public:\n    explicit Greeter(std::string prefix) : prefix_(std::move(prefix)) {}\n\n    // Greet a single recipient.\n    std::string greet(const std::string &name) const {\n        return prefix_ + \", \" + name;\n    }\n\n    // Two greeters are equal when their prefixes match.\n    bool operator==(const Greeter &other) const {\n        return prefix_ == other.prefix_;\n    }\n\n   private:\n    std::string prefix_;\n}",
+    "line_start": 39,
+    "line_end": 56,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "b6cfb7f8d473a7fb",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "method",
+    "name": "Greeter",
+    "scope": "greet::Greeter",
+    "language": "cpp",
+    "content": "explicit Greeter(std::string prefix) : prefix_(std::move(prefix)) {}",
+    "line_start": 42,
+    "line_end": 42,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "719fbd3d44c0eea0",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "method",
+    "name": "greet",
+    "scope": "greet::Greeter",
+    "language": "cpp",
+    "content": "// Greet a single recipient.\n    std::string greet(const std::string &name) const {\n        return prefix_ + \", \" + name;\n    }",
+    "line_start": 44,
+    "line_end": 47,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "87b56da6151de28f",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "method",
+    "name": "operator==",
+    "scope": "greet::Greeter",
+    "language": "cpp",
+    "content": "// Two greeters are equal when their prefixes match.\n    bool operator==(const Greeter &other) const {\n        return prefix_ == other.prefix_;\n    }",
+    "line_start": 49,
+    "line_end": 52,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "0d709abd3b54cc0f",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "function",
+    "name": "format_greeting",
+    "scope": "greet",
+    "language": "cpp",
+    "content": "// Format a greeting using a greeter.\nstd::string format_greeting(const Greeter &g, const std::string &name) {\n    return g.greet(name);\n}",
+    "line_start": 58,
+    "line_end": 61,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "471b8ad76059b629",
+    "blob_sha": "sha1",
+    "file_path": "cpp.cpp",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "cpp",
+    "content": "// namespace greet",
+    "line_start": 63,
+    "line_end": 63,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "529189efb71ce7a6",
+    "blob_sha": "sha1",
+    "file_path": "greeter.hpp",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "cpp",
+    "content": "// Header companion for cpp.cpp — declares the greeter API.\n//\n// Exercises in-class *declared-only* methods (no inline body): the\n// constructor and member functions are captured as methods scoped to\n// their class, just like inline definitions.",
+    "line_start": 1,
+    "line_end": 5,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "25bd5d7d5fb434a9",
+    "blob_sha": "sha1",
+    "file_path": "greeter.hpp",
+    "kind": "import",
+    "name": "#include <string>",
+    "scope": "",
+    "language": "cpp",
+    "content": "#include <string>\n",
+    "line_start": 8,
+    "line_end": 9,
+    "metadata": {
+      "module": "string",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "e5c0d8124297f62b",
+    "blob_sha": "sha1",
+    "file_path": "greeter.hpp",
+    "kind": "class",
+    "name": "greet",
+    "scope": "",
+    "language": "cpp",
+    "content": "namespace greet {\n\nclass Greeting {\npublic:\n    Greeting(std::string prefix);\n    std::string render(const std::string &name) const;\n    static Greeting withDefault();\n\nprivate:\n    std::string prefix_;\n};\n\n}",
+    "line_start": 10,
+    "line_end": 22,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "a292f927d336479b",
+    "blob_sha": "sha1",
+    "file_path": "greeter.hpp",
+    "kind": "class",
+    "name": "Greeting",
+    "scope": "greet",
+    "language": "cpp",
+    "content": "class Greeting {\npublic:\n    Greeting(std::string prefix);\n    std::string render(const std::string &name) const;\n    static Greeting withDefault();\n\nprivate:\n    std::string prefix_;\n}",
+    "line_start": 12,
+    "line_end": 20,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "ebb10d89fefdf8fd",
+    "blob_sha": "sha1",
+    "file_path": "greeter.hpp",
+    "kind": "method",
+    "name": "Greeting",
+    "scope": "greet::Greeting",
+    "language": "cpp",
+    "content": "Greeting(std::string prefix);",
+    "line_start": 14,
+    "line_end": 14,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "85924dfd916f4ebe",
+    "blob_sha": "sha1",
+    "file_path": "greeter.hpp",
+    "kind": "method",
+    "name": "render",
+    "scope": "greet::Greeting",
+    "language": "cpp",
+    "content": "std::string render(const std::string &name) const;",
+    "line_start": 15,
+    "line_end": 15,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "e01bbd19e2d7ea97",
+    "blob_sha": "sha1",
+    "file_path": "greeter.hpp",
+    "kind": "method",
+    "name": "withDefault",
+    "scope": "greet::Greeting",
+    "language": "cpp",
+    "content": "static Greeting withDefault();",
+    "line_start": 16,
+    "line_end": 16,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "0d59d9d8617205fc",
+    "blob_sha": "sha1",
+    "file_path": "greeter.hpp",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "cpp",
+    "content": "// namespace greet",
+    "line_start": 22,
+    "line_end": 22,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  }
+]

rbtr_lang_cpp/tests/cases_docstrings.py

@@ -0,0 +1,58 @@
+"""C++ docstring-extraction test cases.
+
+Each `@case` returns `(lang, source, symbol_name, snippet)` consumed by `test_docstrings.py`.
+"""
+
+from __future__ import annotations
+
+from pytest_cases import case
+
+type DocstringCase = tuple[str, str, str, str]
+
+
+@case(tags=["documented", "canonical", "exterior_doc"])
+def case_cpp_doxygen_on_class() -> DocstringCase:
+    """Doxygen above a C++ class."""
+    src = """\
+/** A widget. */
+class Widget { public: int x; };
+"""
+    return "cpp", src, "Widget", "A widget"
+
+
+@case(tags=["documented", "canonical", "exterior_doc"])
+def case_cpp_doxygen_on_function() -> DocstringCase:
+    """Doxygen above a C++ function."""
+    src = """\
+/** Get the answer. */
+int answer() { return 42; }
+"""
+    return "cpp", src, "answer", "Get the answer"
+
+
+@case(tags=["documented", "edge_case", "exterior_doc"])
+def case_cpp_triple_slash_style() -> DocstringCase:
+    """Doxygen `///` style (single-line convention)."""
+    src = """\
+/// Triple-slash style.
+int foo() { return 0; }
+"""
+    return "cpp", src, "foo", "Triple-slash style"
+
+
+@case(tags=["undocumented", "no_docs"])
+def case_cpp_fn_without_doc() -> DocstringCase:
+    src = """\
+int bare() { return 0; }
+"""
+    return "cpp", src, "bare", "PHANTOM_DOC_TEXT_SHOULD_NEVER_APPEAR"
+
+
+@case(tags=["undocumented", "boundary_not_attached"])
+def case_cpp_doc_detached_by_blank_line() -> DocstringCase:
+    src = """\
+/** Orphan. */
+
+int later() { return 0; }
+"""
+    return "cpp", src, "later", "Orphan"

rbtr_lang_cpp/tests/cases_extraction.py

@@ -0,0 +1,223 @@
+"""C++ extraction test cases."""
+
+from __future__ import annotations
+
+from pytest_cases import case
+
+type SymbolCase = tuple[str, str, list[tuple[str, str, str]]]
+type ImportCase = tuple[str, str, dict[str, str]]
+type MixedCase = tuple[str, str, set[str], list[tuple[str, str]]]
+
+
+@case(tags=["symbol"])
+def case_cpp_free_function_void() -> SymbolCase:
+    """void greet()."""
+    return "cpp", "void greet() { }\n", [("function", "greet", "")]
+
+
+@case(tags=["symbol"])
+def case_cpp_free_function_returning() -> SymbolCase:
+    """int compute(int x)."""
+    return "cpp", "int compute(int x) { return x; }\n", [("function", "compute", "")]
+
+
+@case(tags=["symbol"])
+def case_cpp_multiple_functions() -> SymbolCase:
+    """Multiple C++ functions."""
+    src = """\
+int foo() { return 0; }
+void bar() { }
+"""
+    return "cpp", src, [("function", "foo", ""), ("function", "bar", "")]
+
+
+@case(tags=["symbol"])
+def case_cpp_class() -> SymbolCase:
+    """class Shape."""
+    return "cpp", "class Shape { };\n", [("class", "Shape", "")]
+
+
+@case(tags=["symbol"])
+def case_cpp_struct() -> SymbolCase:
+    """struct Point."""
+    return "cpp", "struct Point { double x; double y; };\n", [("class", "Point", "")]
+
+
+@case(tags=["symbol"])
+def case_cpp_enum_class() -> SymbolCase:
+    """enum class Color."""
+    return "cpp", "enum class Color { Red, Green, Blue };\n", [("class", "Color", "")]
+
+
+@case(tags=["symbol"])
+def case_cpp_class_inheritance() -> SymbolCase:
+    """class Derived : public Base."""
+    src = """\
+class Base { };
+class Derived : public Base { };
+"""
+    return "cpp", src, [("class", "Base", ""), ("class", "Derived", "")]
+
+
+@case(tags=["symbol"])
+def case_cpp_class_method() -> SymbolCase:
+    """Method scoped to class."""
+    src = """\
+class Foo {
+public:
+    void bar() { }
+};
+"""
+    return "cpp", src, [("method", "bar", "Foo")]
+
+
+@case(tags=["symbol"])
+def case_cpp_struct_method() -> SymbolCase:
+    """Method scoped to struct."""
+    return "cpp", "struct Vec { void push(int v) { } };\n", [("method", "push", "Vec")]
+
+
+@case(tags=["symbol"])
+def case_cpp_multiple_methods() -> SymbolCase:
+    """Multiple methods in one class."""
+    src = """\
+class Calculator {
+public:
+    int add(int a, int b) { return a + b; }
+    int sub(int a, int b) { return a - b; }
+};
+"""
+    return "cpp", src, [("method", "add", "Calculator"), ("method", "sub", "Calculator")]
+
+
+@case(tags=["symbol"])
+def case_cpp_namespace_function() -> SymbolCase:
+    """A free function in a namespace is addressed by the namespace.
+
+    C++ `namespace` is not tracked today (`f` → ""); target "ns".
+    """
+    src = """\
+namespace ns {
+void f() { }
+}
+"""
+    return "cpp", src, [("function", "f", "ns")]
+
+
+@case(tags=["symbol"])
+def case_cpp_namespace_class_method() -> SymbolCase:
+    """A method in a class in a namespace carries the full path."""
+    src = """\
+namespace ns {
+class Widget {
+public:
+    void draw() { }
+};
+}
+"""
+    return "cpp", src, [("class", "Widget", "ns"), ("method", "draw", "ns::Widget")]
+
+
+@case(tags=["symbol"])
+def case_cpp_nested_namespace() -> SymbolCase:
+    """Nested namespaces compose outermost-first."""
+    src = """\
+namespace a {
+namespace b {
+void f() { }
+}
+}
+"""
+    return "cpp", src, [("function", "f", "a::b")]
+
+
+@case(tags=["symbol"])
+def case_cpp_namespace_nested_class_method() -> SymbolCase:
+    """A method in nested classes, inside a namespace, composes the full path.
+
+    Mixes a namespace with class nesting — `ns::Outer::Inner`.
+    """
+    src = """\
+namespace ns {
+class Outer {
+public:
+    class Inner {
+    public:
+        void deep() { }
+    };
+};
+}
+"""
+    return "cpp", src, [("method", "deep", "ns::Outer::Inner")]
+
+
+@case(tags=["symbol"])
+def case_cpp_free_function_not_scoped() -> SymbolCase:
+    """Function after class is not scoped."""
+    src = """\
+class C { };
+void standalone() { }
+"""
+    return "cpp", src, [("function", "standalone", "")]
+
+
+@case(tags=["import"])
+def case_cpp_include_system() -> ImportCase:
+    """#include <iostream>."""
+    return "cpp", "#include <iostream>\n", {"module": "iostream"}
+
+
+@case(tags=["import"])
+def case_cpp_include_local() -> ImportCase:
+    """#include "myheader.h"."""
+    return "cpp", '#include "myheader.h"\n', {"module": "myheader.h"}
+
+
+@case(tags=["import"])
+def case_cpp_include_nested() -> ImportCase:
+    """#include <boost/optional.hpp>."""
+    return "cpp", "#include <boost/optional.hpp>\n", {"module": "boost/optional.hpp"}
+
+
+@case(tags=["mixed"])
+def case_cpp_full_file() -> MixedCase:
+    """Realistic C++ file with Doxygen comments.
+
+    Expected tuple unchanged.
+    """
+    src = """\
+#include <vector>
+#include "config.h"
+
+/** Execution engine for the pipeline. */
+class Engine {
+public:
+    void start() { }
+    void stop() { }
+};
+
+/** Options passed to `Engine::start`. */
+struct Options {
+    int timeout;
+};
+
+/** Execution mode — `Fast` skips integrity checks. */
+enum class Mode { Fast, Safe };
+
+/** Drive the engine through a single cycle. */
+void run(Engine& e) {
+    e.start();
+}
+"""
+    return (
+        "cpp",
+        src,
+        {"import", "class", "method", "function"},
+        [("start", "Engine"), ("stop", "Engine")],
+    )
+
+
+@case(tags=["symbol"])
+def case_cpp_global() -> SymbolCase:
+    """File-scope global with initialiser."""
+    return "cpp", "int g = 5;\n", [("variable", "g", "")]

rbtr_lang_cpp/tests/samples/cpp/cpp.cpp

@@ -0,0 +1,63 @@
+// Greeter — format greetings for named recipients.
+//
+// The C++ plugin extracts free functions, prototypes, classes/structs/
+// unions, type aliases, namespaces (as classes and scopes), member
+// functions and operator overloads (as methods), namespace/global
+// variables (including pointer globals), macros, and #include imports.
+
+#include <string>
+
+#include "greeter.hpp"
+
+#define GREET_VERSION 2
+
+const char *kAppName = "greeter"; // trailing comment: its own chunk
+
+// Standalone note, separated by blank lines from any definition.
+// Second line of the same block.
+
+namespace greet {
+
+const std::string DEFAULT_PREFIX = "Hello";
+
+// A short alias for a recipient name.
+using Name = std::string;
+
+// Anything convertible to a std::string can name a recipient.
+template <typename T>
+concept Nameable = std::convertible_to<T, std::string>;
+
+// A tagged greeting payload.
+union Payload {
+    int code;
+    const char *text;
+};
+
+// Build a greeter with the default prefix (declared here).
+Greeter make_default();
+
+// A greeter holding a prefix.
+class Greeter {
+   public:
+    explicit Greeter(std::string prefix) : prefix_(std::move(prefix)) {}
+
+    // Greet a single recipient.
+    std::string greet(const std::string &name) const {
+        return prefix_ + ", " + name;
+    }
+
+    // Two greeters are equal when their prefixes match.
+    bool operator==(const Greeter &other) const {
+        return prefix_ == other.prefix_;
+    }
+
+   private:
+    std::string prefix_;
+};
+
+// Format a greeting using a greeter.
+std::string format_greeting(const Greeter &g, const std::string &name) {
+    return g.greet(name);
+}
+
+}  // namespace greet

rbtr_lang_cpp/tests/samples/cpp/greeter.hpp

@@ -0,0 +1,22 @@
+// Header companion for cpp.cpp — declares the greeter API.
+//
+// Exercises in-class *declared-only* methods (no inline body): the
+// constructor and member functions are captured as methods scoped to
+// their class, just like inline definitions.
+#pragma once
+
+#include <string>
+
+namespace greet {
+
+class Greeting {
+public:
+    Greeting(std::string prefix);
+    std::string render(const std::string &name) const;
+    static Greeting withDefault();
+
+private:
+    std::string prefix_;
+};
+
+}  // namespace greet

rbtr_lang_cpp/tests/test_docstrings.py

@@ -0,0 +1,43 @@
+"""C++ doc-comment extraction (C++ is exterior-doc: leading comments attach via the sibling walk)."""
+
+from __future__ import annotations
+
+from pytest_cases import parametrize_with_cases
+
+from rbtr.git import FileEntry
+from rbtr.languages.extract import extract_file
+
+
+@parametrize_with_cases(
+    "lang, source, name, snippet", cases=".cases_docstrings", has_tag="documented"
+)
+def test_documented_chunk_includes_doc_text(
+    lang: str, source: str, name: str, snippet: str
+) -> None:
+    """By default the chunk content carries the symbol's docs."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    chunk = next(c for c in chunks if c.name == name)
+    assert snippet in chunk.content, f"expected {snippet!r} in {lang}.{name}: {chunk.content!r}"
+
+
+@parametrize_with_cases(
+    "lang, source, name, snippet", cases=".cases_docstrings", has_tag="undocumented"
+)
+def test_no_phantom_documentation(lang: str, source: str, name: str, snippet: str) -> None:
+    """Symbols without documentation do not gain any in content."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    chunk = next(c for c in chunks if c.name == name)
+    assert snippet not in chunk.content, (
+        f"unexpected {snippet!r} in {lang}.{name}: {chunk.content!r}"
+    )
+
+
+@parametrize_with_cases(
+    "lang, source, name, snippet", cases=".cases_docstrings", has_tag="exterior_doc"
+)
+def test_leading_doc_folds_into_symbol(lang: str, source: str, name: str, snippet: str) -> None:
+    """A leading comment block folds into its symbol's chunk content."""
+    chunk = next(
+        c for c in extract_file(FileEntry("input", "sha1", source.encode()), lang) if c.name == name
+    )
+    assert snippet in chunk.content

rbtr_lang_cpp/tests/test_extraction.py

@@ -0,0 +1,43 @@
+"""C++ extraction tests (cases in `cases_extraction.py`)."""
+
+from __future__ import annotations
+
+from pytest_cases import parametrize_with_cases
+
+from rbtr.git import FileEntry
+from rbtr.index.models import ChunkKind, ImportMeta
+from rbtr.languages.extract import extract_file
+
+
+@parametrize_with_cases("lang, source, expected", cases=".cases_extraction", has_tag="symbol")
+def test_extracts_expected_symbols(lang: str, source: str, expected: list) -> None:
+    """Each expected (kind, name, scope) tuple appears in the output."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    symbols = [(c.kind, c.name, c.scope) for c in chunks]
+    for exp in expected:
+        assert exp in symbols, f"expected {exp} not found in {symbols}"
+
+
+@parametrize_with_cases(
+    "lang, source, expected_kinds, expected_methods", cases=".cases_extraction", has_tag="mixed"
+)
+def test_extracts_all_expected_kinds(
+    lang: str, source: str, expected_kinds: set[str], expected_methods: list[tuple[str, str]]
+) -> None:
+    """Realistic source produces all expected chunk kinds and method scoping."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    kinds = {c.kind for c in chunks}
+    for kind in expected_kinds:
+        assert kind in kinds, f"expected kind {kind!r} not in {kinds}"
+    methods = [(c.name, c.scope) for c in chunks if c.kind == ChunkKind.METHOD]
+    for name, scope in expected_methods:
+        assert (name, scope) in methods, f"expected method ({name}, {scope}) not in {methods}"
+
+
+@parametrize_with_cases("lang, source, expected", cases=".cases_extraction", has_tag="import")
+def test_extracts_import_metadata(lang: str, source: str, expected: dict) -> None:
+    """First import chunk has the expected metadata."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    imports = [c for c in chunks if c.kind == ChunkKind.IMPORT]
+    assert len(imports) >= 1, f"no import chunks extracted from {source!r}"
+    assert imports[0].metadata == ImportMeta(**expected)

rbtr_lang_cpp/tests/test_samples.py

@@ -0,0 +1,74 @@
+"""C++ sample extraction: the `samples/cpp/` project through the real pipeline."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pytest
+from tree_sitter import Parser
+
+from rbtr.git import FileEntry
+from rbtr.index.models import Chunk, ChunkKind, Edge
+from rbtr.languages.edges import build_resolution_map, infer_import_edges
+from rbtr.languages.extract import extract_file
+from rbtr.languages.manager import get_manager
+from rbtr.testing import render_edges
+
+if TYPE_CHECKING:
+    from syrupy.assertion import SnapshotAssertion
+
+
+@pytest.fixture
+def project() -> list[tuple[str, str]]:
+    root = Path(__file__).parent / "samples" / "cpp"
+    return [
+        (str(p.relative_to(root)), p.read_text()) for p in sorted(root.rglob("*")) if p.is_file()
+    ]
+
+
+@pytest.fixture
+def chunks(project: list[tuple[str, str]]) -> list[Chunk]:
+    manager = get_manager()
+    out: list[Chunk] = []
+    for path, text in project:
+        lang = manager.detect_language(path) or "cpp"
+        out.extend(extract_file(FileEntry(path, "sha1", text.encode()), lang))
+    return out
+
+
+@pytest.fixture
+def edges(project: list[tuple[str, str]], chunks: list[Chunk]) -> list[Edge]:
+    manager = get_manager()
+    repo_files = {path for path, _ in project}
+    return infer_import_edges(chunks, repo_files, build_resolution_map(manager))
+
+
+def test_emits_expected_kinds(chunks: list[Chunk]) -> None:
+    kinds = {c.kind for c in chunks}
+    assert {
+        ChunkKind.FUNCTION,
+        ChunkKind.CLASS,
+        ChunkKind.METHOD,
+        ChunkKind.VARIABLE,
+        ChunkKind.IMPORT,
+        ChunkKind.COMMENT,
+    } <= kinds
+
+
+def test_parses_cleanly(project: list[tuple[str, str]]) -> None:
+    manager = get_manager()
+    for path, text in project:
+        grammar = manager.grammar(manager.detect_language(path) or "cpp")
+        assert grammar is not None
+        assert not Parser(grammar).parse(text.encode()).root_node.has_error, path
+
+
+def test_extraction_matches_snapshot(chunks: list[Chunk], snapshot_json: SnapshotAssertion) -> None:
+    assert chunks == snapshot_json
+
+
+def test_edges_match_snapshot(
+    chunks: list[Chunk], edges: list[Edge], snapshot_json: SnapshotAssertion
+) -> None:
+    assert render_edges(edges, chunks) == snapshot_json

rbtr_lang_cpp-2026.7.0.dev0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: rbtr-lang-cpp
+Version: 2026.7.0.dev0
+Summary: rbtr — C++ language plugin
+License-Expression: MIT
+Requires-Dist: rbtr==2026.7.0.dev0
+Requires-Dist: tree-sitter-cpp
+Requires-Python: >=3.13

rbtr_lang_cpp-2026.7.0.dev0.dist-info/RECORD

@@ -0,0 +1,18 @@
+rbtr_lang_cpp/__init__.py,sha256=Hef94LjfHmbWBqOEJbyDkpSzWjYqxPXuslegwfHMD5s,35
+rbtr_lang_cpp/cpp.scm,sha256=QrhrdROxX6W8uUUon8WWU6C0zkXy_Bd-qOSxMfyvD5k,2729
+rbtr_lang_cpp/plugin.py,sha256=-fVX3jbkUGFrglJiMJ0_6vXNq4pDFh49ACKLbbxkqX0,1703
+rbtr_lang_cpp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rbtr_lang_cpp/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rbtr_lang_cpp/tests/__snapshots__/test_samples/test_edges_match_snapshot.json,sha256=Hlo6vUD_r6RMxcV313kVRo4xFwJ7MjbNGcYL8-ri3IM,371
+rbtr_lang_cpp/tests/__snapshots__/test_samples/test_extraction_matches_snapshot.json,sha256=qrZFR70cajx5lmPUAfBUmV3STHbuA_3A_8JxPObaQuU,13369
+rbtr_lang_cpp/tests/cases_docstrings.py,sha256=QZhOC6DCNjsv_0FXVsHxEPZYyZFtdwbNCELCPFlboTM,1489
+rbtr_lang_cpp/tests/cases_extraction.py,sha256=ZoSMv2NQ2hVwCmnZ2yKyBkWv6BnnGiBMYGpyP83gbCE,5338
+rbtr_lang_cpp/tests/samples/cpp/cpp.cpp,sha256=x-TqDyDrLWWDQGAsH7YEMPHhYU1X0oIadFbBiSR85Hw,1642
+rbtr_lang_cpp/tests/samples/cpp/greeter.hpp,sha256=19ZQl0dce_aYBhdP4dLjlu8rWcjOuaOqjPD-NhKdd5U,511
+rbtr_lang_cpp/tests/test_docstrings.py,sha256=X5x3rMCC4o3AemYDVgq5N-97j_MSKe9CL5DBGCobSbo,1750
+rbtr_lang_cpp/tests/test_extraction.py,sha256=tPmLyWaP6WdscoGkEK3CH2OZWSnpp5Z_YI2-AhTKjrs,2057
+rbtr_lang_cpp/tests/test_samples.py,sha256=V4VTbjenW3F49RqInFy0PSHgh4cCyXBZRClkCYLRt6k,2295
+rbtr_lang_cpp-2026.7.0.dev0.dist-info/WHEEL,sha256=CoDSoyhtC_eO_tlxRYzsTraPv1fPJRXFx91k6ISeAvA,81
+rbtr_lang_cpp-2026.7.0.dev0.dist-info/entry_points.txt,sha256=b1-9T3HIJxCYvLPXjcVZpVbHUZFSNTFlgAfUK9AbR2w,49
+rbtr_lang_cpp-2026.7.0.dev0.dist-info/METADATA,sha256=hkahgj7lhDyaqwC5z8m5wKuB0cIWQq_n6NOGLxZouKk,217
+rbtr_lang_cpp-2026.7.0.dev0.dist-info/RECORD,,

rbtr_lang_cpp-2026.7.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.28
+Root-Is-Purelib: true
+Tag: py3-none-any

rbtr_lang_cpp-2026.7.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[rbtr.languages]
+cpp = rbtr_lang_cpp.plugin:cpp
+