feat(extraction): index Metal (.metal) and CUDA (.cu/.cuh) via the C++ grammar (#147)

Ports the Metal and CUDA language support from upstream colby 1.2.0..1.4.1 (the
two cheapest additions, since both dialects are close enough to C++ that the
existing tree-sitter-cpp grammar extracts them). Both map to Language::Cpp — no
new language variant, no new grammar crate, no new dependency, and the golden
.schema is unchanged.

- Metal (#1121): .metal maps to the C++ grammar. MSL puts attributes after the
  declarator (`float4 pos [[position]];`), a shape tree-sitter-cpp misparses
  into a spurious inheritance edge from the struct to a field's type. An
  offset-preserving pre-parse pass blanks `[[attribute]]` annotations, gated to
  .metal files only — in regular C++ the pre-declarator `[[nodiscard]]` position
  is legal syntax the grammar parses natively and is left byte-identical.

- CUDA (#1172, language parts only — the namespace-qualified-name and
  template-argument-call work from the same upstream commit already shipped in
  v0.31.0 and is not re-ported here): .cu/.cuh map to the C++ grammar, and CUDA
  in a plain .h/.hpp is recognized by content. The host->kernel call edge now
  survives the `<<<grid, block>>>` launch syntax — an offset-preserving,
  brace-balanced pre-parse blank of the launch config leaves `kernel(args)` as
  an ordinary resolvable call (templated launches ride the existing template-arg
  stripping). Kernels defined through a name-in-first-argument macro
  (`DEFINE_FLASH_FORWARD_KERNEL(name, ...)`) are indexed under their real name,
  with the macro-name recovery tightly gated so gtest-style `TEST(...)` and
  ordinary macro calls are untouched. The `<<<>>>` and CUDA-construct blanks fire
  only for CUDA files/content, so non-CUDA C++ is byte-identical.

New dedicated `metal` and `cuda` golden fixtures guard the behavior; the
existing cpp/godot/ruby/mini goldens and the .schema are byte-identical (no
regen). Local function-pointer launch dispatch is deferred.

Author: sunerpy

crates/codegraph-bench/fixtures/cuda/kernel.cu

@@ -0,0 +1,18 @@
+__global__ void add_kernel(int* out, const int* a, const int* b) {
+    int i = 0;
+    out[i] = a[i] + b[i];
+}
+
+template <typename T, int N>
+__global__ void scale_kernel(T* x, T factor) {
+    x[0] = x[0] * factor;
+}
+
+DEFINE_FLASH_FORWARD_KERNEL(my_kernel, int n) {
+    int i = n;
+}
+
+void launch(int* out, const int* a, const int* b, float* data) {
+    add_kernel<<<grid, block>>>(out, a, b);
+    scale_kernel<float, 256><<<grid, block>>>(data, 2.0f);
+}

crates/codegraph-bench/fixtures/metal/shader.metal

@@ -0,0 +1,24 @@
+struct float4 {
+    float x;
+    float y;
+    float z;
+    float w;
+};
+
+struct float2 {
+    float u;
+    float v;
+};
+
+struct VertexIn {
+    float4 position [[position]];
+    float2 uv [[user(locn0)]];
+};
+
+float4 tint(float4 color) {
+    return color;
+}
+
+vertex float4 vertex_main(VertexIn in [[stage_in]]) {
+    return tint(in.position);
+}

crates/codegraph-bench/tests/equivalence.rs

@@ -79,6 +79,43 @@ fn cpp_db_is_self_equivalent_to_cpp_golden() {
     assert_equivalent(&cpp_db(), &cpp_golden_dir()).unwrap();
 }
 
+#[test]
+fn generated_golden_matches_committed_metal_fixture() {
+    // Guards Metal (#1121): `.metal`→cpp mapping + the `[[attribute]]` blank that
+    // prevents the spurious `VertexIn extends float4` inheritance edge.
+    let tempdir = TestDir::new("generated-golden-metal");
+    write_golden(&metal_db(), tempdir.path()).unwrap();
+
+    let expected = load_golden(&metal_golden_dir()).unwrap();
+    let actual = load_golden(tempdir.path()).unwrap();
+
+    diff_canonical(&expected, &actual, None).unwrap();
+}
+
+#[test]
+fn metal_db_is_self_equivalent_to_metal_golden() {
+    assert_equivalent(&metal_db(), &metal_golden_dir()).unwrap();
+}
+
+#[test]
+fn generated_golden_matches_committed_cuda_fixture() {
+    // Guards CUDA (#1172 CUDA-lang parts): `.cu`→cpp mapping, the `<<<…>>>`
+    // launch-config blank that preserves the host→kernel Calls edge (plain +
+    // templated), and macro-defined-kernel name recovery (`my_kernel`).
+    let tempdir = TestDir::new("generated-golden-cuda");
+    write_golden(&cuda_db(), tempdir.path()).unwrap();
+
+    let expected = load_golden(&cuda_golden_dir()).unwrap();
+    let actual = load_golden(tempdir.path()).unwrap();
+
+    diff_canonical(&expected, &actual, None).unwrap();
+}
+
+#[test]
+fn cuda_db_is_self_equivalent_to_cuda_golden() {
+    assert_equivalent(&cuda_db(), &cuda_golden_dir()).unwrap();
+}
+
 #[test]
 fn tier1_node_drift_is_reported() {
     let expected = load_golden(&mini_golden_dir()).unwrap();
@@ -157,6 +194,22 @@ fn cpp_golden_dir() -> PathBuf {
     workspace_root().join("reference/golden/cpp")
 }
 
+fn metal_db() -> PathBuf {
+    workspace_root().join("reference/golden/metal/colby.db")
+}
+
+fn metal_golden_dir() -> PathBuf {
+    workspace_root().join("reference/golden/metal")
+}
+
+fn cuda_db() -> PathBuf {
+    workspace_root().join("reference/golden/cuda/colby.db")
+}
+
+fn cuda_golden_dir() -> PathBuf {
+    workspace_root().join("reference/golden/cuda")
+}
+
 struct TestDir {
     path: PathBuf,
 }

crates/codegraph-extract/src/engine.rs

@@ -58,6 +58,10 @@ pub fn builtin_language_for_ext(ext: &str) -> Option<Language> {
         "java" => Language::Java,
         "c" | "h" => Language::C,
         "cpp" | "cc" | "cxx" | "hpp" | "hxx" => Language::Cpp,
+        // Metal Shading Language (≈ C++14) and CUDA (≈ C++ + dialect tokens) both
+        // ride the C++ grammar with a dialect-specific pre-parse blank; no new
+        // `Language` variant (upstream maps all three to `cpp`).
+        "metal" | "cu" | "cuh" => Language::Cpp,
         "cs" => Language::CSharp,
         "php" | "module" | "install" | "theme" | "inc" => Language::Php,
         "rb" | "rake" => Language::Ruby,
@@ -203,7 +207,7 @@ pub fn extract_source(
             duration_ms: start.elapsed().as_millis() as i64,
         };
     }
-    let parsed_source = spec.pre_parse(source);
+    let parsed_source = spec.pre_parse(source, file_path);
     let Some(tree) = parser.parse(&parsed_source, None) else {
         return ExtractionResult {
             nodes: Vec::new(),
@@ -859,6 +863,14 @@ mod tests {
         assert_eq!(detect_language("src/lib.rs"), Language::Rust);
     }
 
+    #[test]
+    fn metal_cu_cuh_map_to_cpp() {
+        assert_eq!(detect_language("s.metal"), Language::Cpp);
+        assert_eq!(detect_language("k.cu"), Language::Cpp);
+        assert_eq!(detect_language("k.cuh"), Language::Cpp);
+        assert_eq!(Language::ALL.len(), 36);
+    }
+
     #[test]
     fn extract_source_unknown_language_yields_empty_no_error() {
         let result = extract_source("mystery.unknownext", "content", None);

crates/codegraph-extract/src/lang/c.rs

@@ -79,6 +79,13 @@ impl LanguageSpec for CSpec {
     fn extract_import(&self, node: Node<'_>, source: &str) -> Option<ImportInfo> {
         include_import(node, source)
     }
+    fn pre_parse(&self, source: &str, _file_path: &str) -> String {
+        if crate::lang::cpp::looks_like_cuda_source(source) {
+            crate::lang::cpp::blank_cuda_constructs_str(source)
+        } else {
+            source.to_string()
+        }
+    }
 }
 
 pub(crate) fn include_import(node: Node<'_>, source: &str) -> Option<ImportInfo> {
@@ -177,3 +184,21 @@ fn valid_ident(text: &str) -> bool {
         .is_some_and(|c| c == '_' || c.is_ascii_alphabetic())
         && chars.all(|c| c == '_' || c.is_ascii_alphanumeric())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn c_header_cuda_content_blanked() {
+        let out = CSpec.pre_parse("__device__ int helper() { return 0; }", "h.h");
+        assert!(!out.contains("__device__"));
+        assert_eq!(out.len(), "__device__ int helper() { return 0; }".len());
+    }
+
+    #[test]
+    fn c_plain_untouched() {
+        let src = "int add(int a, int b) { return a + b; }";
+        assert_eq!(CSpec.pre_parse(src, "m.c"), src);
+    }
+}