Merge branch 'main' into fix/cypher-coalesce-where-874

Author: harshitaajoshi

internal/cbm/extract_defs.c

@@ -1317,7 +1317,8 @@ static const char *annotation_route_method(const char *name) {
     }
     /* JAX-RS bare-verb annotations (@GET/@POST/...) — path comes from @Path. */
     if (strcmp(name, "GET") == 0 || strcmp(name, "POST") == 0 || strcmp(name, "PUT") == 0 ||
-        strcmp(name, "DELETE") == 0 || strcmp(name, "PATCH") == 0) {
+        strcmp(name, "DELETE") == 0 || strcmp(name, "PATCH") == 0 || strcmp(name, "HEAD") == 0 ||
+        strcmp(name, "OPTIONS") == 0) {
         return name;
     }
     return NULL;
@@ -1626,35 +1627,85 @@ static bool try_route_from_annotation(CBMArena *a, TSNode annotation, const char
     return true;
 }
 
-/* Scan the annotation nodes nested in a JVM/C# `modifiers`/`attribute_list`
- * wrapper (and direct children) for a route-mapping annotation. Java/Kotlin
- * Spring annotations (@GetMapping, @RequestMapping, ...) live here rather than
- * as prev-siblings, so the prev-sibling decorator walk never sees them. */
-static bool extract_route_from_annotations(CBMArena *a, TSNode func_node, const char *source,
-                                           const CBMLangSpec *spec, const char **out_path,
-                                           const char **out_method) {
-    TSNode modifiers = find_jvm_modifiers(func_node, spec->language);
+/* Scan ALL annotation nodes nested in a JVM/C# `modifiers`/`attribute_list`
+ * wrapper (and direct children), collecting route information from the whole
+ * set instead of stopping at the first mapping annotation. Java/Kotlin Spring
+ * annotations (@GetMapping, @RequestMapping, ...) live here rather than as
+ * prev-siblings, so the prev-sibling decorator walk never sees them.
+ *
+ * JAX-RS splits the route across two annotations: the verb comes from a bare
+ * @GET/@POST/... and the path from a sibling @Path("..."). Returning on the
+ * first mapping annotation therefore dropped every method-level @Path
+ * (the @GET matched first, defaulted the path to "/", and @Path was never
+ * read), and class-level @Path prefixes were never recognized at all. */
+static void scan_route_annotations(CBMArena *a, TSNode owner, const char *source,
+                                   const CBMLangSpec *spec, const char **out_map_path,
+                                   const char **out_method, const char **out_jax_path) {
+    *out_map_path = NULL;
+    *out_method = NULL;
+    *out_jax_path = NULL;
+
+    TSNode wrappers[2];
+    int wn = 0;
+    TSNode modifiers = find_jvm_modifiers(owner, spec->language);
     if (!ts_node_is_null(modifiers)) {
-        uint32_t mc = ts_node_child_count(modifiers);
-        for (uint32_t mi = 0; mi < mc; mi++) {
-            TSNode mchild = ts_node_child(modifiers, mi);
-            if (cbm_kind_in_set(mchild, spec->decorator_node_types) &&
-                try_route_from_annotation(a, mchild, source, out_path, out_method)) {
-                return true;
-            }
-        }
+        wrappers[wn++] = modifiers;
     }
     /* Direct-child annotations (some grammars attach the annotation as a child
      * of the method node rather than under `modifiers`). */
-    uint32_t cc = ts_node_child_count(func_node);
-    for (uint32_t ci = 0; ci < cc; ci++) {
-        TSNode child = ts_node_child(func_node, ci);
-        if (cbm_kind_in_set(child, spec->decorator_node_types) &&
-            try_route_from_annotation(a, child, source, out_path, out_method)) {
-            return true;
+    wrappers[wn++] = owner;
+
+    for (int w = 0; w < wn; w++) {
+        uint32_t cc = ts_node_child_count(wrappers[w]);
+        for (uint32_t ci = 0; ci < cc; ci++) {
+            TSNode child = ts_node_child(wrappers[w], ci);
+            if (!cbm_kind_in_set(child, spec->decorator_node_types)) {
+                continue;
+            }
+            TSNode name_node = annotation_name_node(child);
+            if (ts_node_is_null(name_node)) {
+                continue;
+            }
+            char *name = cbm_node_text(a, name_node, source);
+            if (!name) {
+                continue;
+            }
+            if (!*out_jax_path && strcmp(name, "Path") == 0) {
+                TSNode args = annotation_args_node(child);
+                if (!ts_node_is_null(args)) {
+                    *out_jax_path = extract_route_path_from_args(a, args, source);
+                }
+                continue;
+            }
+            if (!*out_method) {
+                const char *method = annotation_route_method(name);
+                if (method) {
+                    *out_method = method;
+                    TSNode args = annotation_args_node(child);
+                    if (!ts_node_is_null(args)) {
+                        *out_map_path = extract_route_path_from_args(a, args, source);
+                    }
+                }
+            }
         }
     }
-    return false;
+}
+
+static bool extract_route_from_annotations(CBMArena *a, TSNode func_node, const char *source,
+                                           const CBMLangSpec *spec, const char **out_path,
+                                           const char **out_method) {
+    const char *map_path = NULL;
+    const char *method = NULL;
+    const char *jax_path = NULL;
+    scan_route_annotations(a, func_node, source, spec, &map_path, &method, &jax_path);
+    /* Method-level routes still require a verb/mapping annotation; a lone
+     * @Path (JAX-RS sub-resource locator) is not an endpoint by itself. */
+    if (!method) {
+        return false;
+    }
+    *out_method = method;
+    *out_path = map_path ? map_path : (jax_path ? jax_path : "/");
+    return true;
 }
 
 static void extract_route_from_decorators(CBMArena *a, TSNode func_node, const char *source,
@@ -1723,10 +1774,18 @@ static const char *join_route_paths(CBMArena *a, const char *prefix, const char
 
 static const char *spring_class_route_prefix(CBMArena *a, TSNode class_node, const char *source,
                                              const CBMLangSpec *spec) {
-    const char *prefix = NULL;
+    const char *map_path = NULL;
     const char *method = NULL;
-    if (extract_route_from_annotations(a, class_node, source, spec, &prefix, &method)) {
-        return prefix;
+    const char *jax_path = NULL;
+    scan_route_annotations(a, class_node, source, spec, &map_path, &method, &jax_path);
+    if (map_path) {
+        return map_path; /* @RequestMapping("/api") and friends */
+    }
+    if (jax_path) {
+        return jax_path; /* JAX-RS class-level @Path("/api") carries no verb */
+    }
+    if (method) {
+        return "/"; /* mapping annotation without a path argument */
     }
     return NULL;
 }
@@ -5901,8 +5960,8 @@ static void extract_class_fields(CBMExtractCtx *ctx, TSNode class_node, const ch
          * For the nested case, the child has no "type" field directly. Detect by
          * walking named children for a variable_declaration. */
         TSNode type_node = ts_node_child_by_field_name(child, TS_FIELD("type"));
-        TSNode name_node =
-            ts_node_is_null(type_node) ? (TSNode){0} : resolve_field_name_node(child);
+        TSNode empty_node = {0};
+        TSNode name_node = ts_node_is_null(type_node) ? empty_node : resolve_field_name_node(child);
 
         if (ts_node_is_null(type_node)) {
             uint32_t cnc = ts_node_named_child_count(child);

src/mcp/mcp.c

@@ -1793,10 +1793,23 @@ static bool db_internal_project_name(const char *full_path, char *name_out, size
     cbm_project_t *projs = NULL;
     int n = 0;
     bool ok = false;
-    if (cbm_store_list_projects(st, &projs, &n) == CBM_STORE_OK && n == 1 && projs[0].name &&
-        projs[0].name[0]) {
-        snprintf(name_out, name_sz, "%s", projs[0].name);
-        ok = true;
+    if (cbm_store_list_projects(st, &projs, &n) == CBM_STORE_OK) {
+        /* Ignore internal shadow projects ("<name>::missed" miss-graph rows):
+         * they share the db with the primary project and must not make it
+         * unresolvable — requiring n == 1 over ALL rows made every project
+         * with a miss graph vanish from list_projects and the UI (#1044). */
+        int primary = -1;
+        int primary_count = 0;
+        for (int i = 0; i < n; i++) {
+            if (projs[i].name && projs[i].name[0] && !strstr(projs[i].name, "::")) {
+                primary = i;
+                primary_count++;
+            }
+        }
+        if (primary_count == 1) {
+            snprintf(name_out, name_sz, "%s", projs[primary].name);
+            ok = true;
+        }
     }
     cbm_store_free_projects(projs, n);
     if (ok && out_store) {

src/pipeline/pass_pkgmap.c

@@ -426,8 +426,12 @@ static void parse_pyproject_toml(const char *source, int source_len, const char
     pkg_entries_push(entries, name, entry);
 
     /* Also register <name>/__init__ as alternative (no src/ prefix) */
-    snprintf(suffix, sizeof(suffix), "%s/__init__", name_copy);
-    char *alt_entry = build_entry_path(rel_path, suffix);
+    char *alt_entry = NULL;
+    if (name_copy) {
+        snprintf(suffix, sizeof(suffix), "%s/__init__", name_copy);
+        alt_entry = build_entry_path(rel_path, suffix);
+    }
+
     if (name_copy && alt_entry) {
         pkg_entries_push(entries, name_copy, alt_entry);
     } else {
@@ -1265,6 +1269,151 @@ static bool import_targetable_label(const char *label) {
     return false;
 }
 
+static const char *path_leaf(const char *path) {
+    const char *leaf = path;
+    for (const char *p = path; p && *p; p++) {
+        if (*p == '/' || *p == '\\') {
+            leaf = p + 1;
+        }
+    }
+    return leaf;
+}
+
+static bool is_header_include(const char *path) {
+    if (!path || !path[0]) {
+        return false;
+    }
+    static const char *header_exts[] = {".h", ".hh", ".hpp", ".hxx", ".inc", ".inl", ".ipp", NULL};
+    for (const char **ext = header_exts; *ext; ext++) {
+        size_t path_len = strlen(path);
+        size_t ext_len = strlen(*ext);
+        if (path_len > ext_len && strcmp(path + path_len - ext_len, *ext) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool is_c_family_source(const char *source_rel) {
+    if (!source_rel || !source_rel[0]) {
+        return false;
+    }
+    static const char *exts[] = {".c", ".cc", ".cpp", ".cxx", ".c++",
+                                 ".h", ".hh", ".hpp", ".hxx", NULL};
+    for (const char **ext = exts; *ext; ext++) {
+        size_t path_len = strlen(source_rel);
+        size_t ext_len = strlen(*ext);
+        if (path_len > ext_len && strcmp(source_rel + path_len - ext_len, *ext) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static const cbm_gbuf_node_t *resolve_exact_file_node(const cbm_pipeline_ctx_t *ctx,
+                                                      const char *file_path,
+                                                      const char *source_file_qn) {
+    if (!ctx || !file_path || !file_path[0]) {
+        return NULL;
+    }
+
+    const char *leaf = path_leaf(file_path);
+    if (!leaf || !leaf[0]) {
+        return NULL;
+    }
+
+    char stem[PKGMAP_PATH_BUF];
+    snprintf(stem, sizeof(stem), "%s", leaf);
+    char *last_dot = strrchr(stem, '.');
+    if (last_dot && last_dot != stem) {
+        *last_dot = '\0';
+    }
+
+    const char *names[2] = {stem[0] ? stem : NULL, leaf};
+    const cbm_gbuf_node_t *best = NULL;
+    for (int ni = 0; ni < 2; ni++) {
+        const char *name = names[ni];
+        if (!name || !name[0]) {
+            continue;
+        }
+
+        const cbm_gbuf_node_t **hits = NULL;
+        int hit_count = 0;
+        if (cbm_gbuf_find_by_name(ctx->gbuf, name, &hits, &hit_count) != 0 || !hits) {
+            continue;
+        }
+
+        for (int i = 0; i < hit_count; i++) {
+            const cbm_gbuf_node_t *cand = hits[i];
+            if (!cand || !cand->file_path) {
+                continue;
+            }
+
+            /* Tie-breaker: Ensure the candidate's actual file_path ends with the
+             * specific include path requested (e.g., 'a/util.h' instead of just 'util.h'). */
+            if (!ends_with(cand->file_path, file_path)) {
+                continue;
+            }
+
+            if (!cand->label || !import_targetable_label(cand->label)) {
+                continue;
+            }
+            if (source_file_qn && cand->qualified_name &&
+                strcmp(cand->qualified_name, source_file_qn) == 0) {
+                continue;
+            }
+            if (strcmp(cand->label, "File") == 0) {
+                return cand;
+            }
+            if (!best) {
+                best = cand;
+            }
+        }
+        if (best) {
+            return best;
+        }
+    }
+    return NULL;
+}
+
+static const cbm_gbuf_node_t *resolve_header_include(const cbm_pipeline_ctx_t *ctx,
+                                                     const char *source_rel,
+                                                     const char *source_file_qn,
+                                                     const char *module_path) {
+    if (!is_c_family_source(source_rel) || !is_header_include(module_path)) {
+        return NULL;
+    }
+
+    const char *base = module_path;
+    if (base[0] == '.' && base[1] == '/') {
+        base += 2;
+    }
+
+    const cbm_gbuf_node_t *exact = resolve_exact_file_node(ctx, base, source_file_qn);
+    if (exact) {
+        return exact;
+    }
+
+    if (source_rel && source_rel[0]) {
+        char *dir = path_dirname(source_rel);
+        if (dir) {
+            char candidate[PKGMAP_PATH_BUF];
+            if (dir[0]) {
+                snprintf(candidate, sizeof(candidate), "%s/%s", dir, base);
+            } else {
+                snprintf(candidate, sizeof(candidate), "%s", base);
+            }
+            free(dir);
+            exact = resolve_exact_file_node(ctx, candidate, source_file_qn);
+            if (exact) {
+                return exact;
+            }
+        }
+    }
+
+    return NULL;
+}
+
 /* Resolve a sibling-file import: a bare path/name (no leading "./") that names
  * a file relative to the importer's directory.  This covers build/markup
  * grammars whose import string is a sibling filename or directory rather than a
@@ -1352,6 +1501,14 @@ const cbm_gbuf_node_t *cbm_pipeline_resolve_import_node(const cbm_pipeline_ctx_t
         return NULL;
     }
 
+    /* Prefer exact header-file nodes for C/C++ includes so same-stem source or
+     * module nodes do not steal the edge target. */
+    const cbm_gbuf_node_t *header_target =
+        resolve_header_include(ctx, source_rel, source_file_qn, imp->module_path);
+    if (header_target) {
+        return header_target;
+    }
+
     /* Strategy 1: module-path resolution → existing node (Python/TS/Go).
      * No label filter here: directory-module languages (Go/Java packages)
      * legitimately resolve straight to a Folder node -- that's the intended,

src/pipeline/pipeline_incremental.c

@@ -885,8 +885,17 @@ int cbm_pipeline_run_incremental(cbm_pipeline_t *p, const char *db_path, cbm_fil
     for (int i = 0; i < ci; i++) {
         char *file_qn = cbm_pipeline_fqn_compute(project, changed_files[i].rel_path, "__file__");
         if (file_qn) {
-            cbm_gbuf_upsert_node(existing, "File", changed_files[i].rel_path, file_qn,
-                                 changed_files[i].rel_path, 0, 0, "{}");
+            /* #994: the name must be the BASENAME with extension props,
+             * mirroring the full build's File node (pipeline.c) — upserts
+             * match by QN, so any other name here renames the node in place
+             * and the incremental graph diverges from a full build. */
+            const char *rel = changed_files[i].rel_path;
+            const char *slash = strrchr(rel, '/');
+            const char *basename = slash ? slash + SKIP_ONE : rel;
+            char props[CBM_SZ_256];
+            const char *ext = strrchr(basename, '.');
+            snprintf(props, sizeof(props), "{\"extension\":\"%s\"}", ext ? ext : "");
+            cbm_gbuf_upsert_node(existing, "File", basename, file_qn, rel, 0, 0, props);
             free(file_qn);
         }
     }

tests/fixtures/cpp_include/NodeController.cpp

@@ -0,0 +1,5 @@
+#include "NodeController.h"
+
+int node_controller_value() {
+    return 1;
+}

tests/fixtures/cpp_include/NodeController.h

@@ -0,0 +1,5 @@
+#pragma once
+
+struct NodeController {
+    int value;
+};