Break-glass merge PR #2520

Author: DeusData

internal/cbm/lsp/php_lsp.c

@@ -7,6 +7,15 @@
 #include "../cbm.h"
 #include "go_lsp.h"  /* CBMLSPDef reused across languages */
 
+/* Per-file typed import evidence. NULL targets means unknown; otherwise
+ * targets has one slot per represented import, NULL only for a binding whose
+ * absence was established. Any unsupported unresolved binding makes the whole
+ * file unknown. The array is caller-owned; strings and import records borrowed. */
+typedef struct {
+    const CBMImportArray *imports;
+    const char **targets;
+} CBMPHPImportBindings;
+
 /* PHPLSPContext — per-file state for PHP type-aware call resolution.
  * Mirrors GoLSPContext / CLSPContext structure. */
 typedef struct {
@@ -28,6 +37,13 @@ typedef struct {
     int use_count;
     int use_cap;
 
+    /* Cross-file mode: dotted targets of the file's class `use` declarations
+     * that the pipeline's import map left unresolved (vendor / unmapped
+     * namespaces, #1186). A type named through one is outside the project: it
+     * never matches a project type by short name. */
+    const char **external_use_qns;
+    int external_use_count;
+
     /* Current function/method/class context. */
     const char *enclosing_func_qn;
     const char *enclosing_class_qn; /* NULL outside class body */
@@ -116,6 +132,15 @@ void cbm_run_php_lsp_cross(
     TSTree *cached_tree,           /* NULL = parse internally */
     CBMResolvedCallArray *out);
 
+/* Complete typed bindings enable external receiver evidence. */
+void cbm_run_php_lsp_cross_with_bindings(CBMArena *arena, const char *source, int source_len,
+                                         const char *module_qn, CBMLSPDef *defs, int def_count,
+                                         const char **import_names, const char **import_qns,
+                                         int import_count,
+                                         TSTree *cached_tree, /* NULL = parse internally */
+                                         CBMResolvedCallArray *out,
+                                         const CBMPHPImportBindings *bindings);
+
 /* --- Batch cross-file LSP --- */
 
 /* Per-file input for batch PHP LSP processing. */

internal/cbm/lsp/php_lsp.h

@@ -27,6 +27,7 @@
 #include "graph_buffer/graph_buffer.h"
 #include "foundation/constants.h"
 #include "pipeline/pipeline.h" /* cbm_registry_unique_field_qn, cbm_resolution_t */
+#include "service_patterns.h"  /* cbm_service_pattern_match for cbm_pipeline_service_name */
 
 #include <ctype.h>
 #include <stdio.h>
@@ -333,6 +334,34 @@ static inline int cbm_pipeline_invocation_site_rank(const CBMResolvedCall *resol
     return call->requires_lsp_resolution || call->source_origin != resolved->source_origin ? 0 : 1;
 }
 
+/* A resolver row that proves the call's receiver is a type OUTSIDE the project:
+ * PHP `$r->m()` / `R::m()` where `R` is imported from a vendor namespace
+ * (#1186). When its target has no graph node, it rules out every name-only
+ * fallback: the method of a vendor class is not a same-named project method. */
+static inline bool cbm_pipeline_lsp_external_receiver(const CBMResolvedCall *resolved) {
+    return resolved && resolved->strategy &&
+           strcmp(resolved->strategy, "php_external_receiver") == 0;
+}
+
+/* The service-pattern name of a call: its callee text, or, when that names no
+ * service and the LSP proved the receiver a vendor class, the vendor method
+ * (`GuzzleClient::get` -> `GuzzleHttp.Client.get`). The extractor names a
+ * scoped call by its method alone, and such a call never reaches the
+ * registry, so the vendor class is its only service evidence (#1186). */
+static inline const char *cbm_pipeline_service_name(const CBMCall *call,
+                                                    const CBMResolvedCall *external,
+                                                    cbm_svc_kind_t *kind) {
+    *kind = cbm_service_pattern_match(call->callee_name);
+    if (*kind == CBM_SVC_NONE && cbm_pipeline_lsp_external_receiver(external) &&
+        external->callee_qn && external->callee_qn[0]) {
+        *kind = cbm_service_pattern_match(external->callee_qn);
+        if (*kind != CBM_SVC_NONE) {
+            return external->callee_qn;
+        }
+    }
+    return call->callee_name;
+}
+
 static inline bool cbm_pipeline_invocation_reason_join_strategy(const char *strategy) {
     return strategy &&
            (strcmp(strategy, "lsp_func_ptr") == 0 || strcmp(strategy, "lsp_callable_alias") == 0 ||

src/pipeline/lsp_resolve.h

@@ -457,10 +457,11 @@ static int64_t create_svc_route_node(cbm_pipeline_ctx_t *ctx, const char *url, c
 
 /* Insert an edge, splicing the call-site line (,"line":N) in before the closing
  * brace when one was captured. Mirrors finalize_and_emit() on the parallel path
- * so CALLS edges carry their source line regardless of resolution path. Restricted
- * to CALLS: route/config edge props feed full-only predump passes
- * (create_route_nodes/create_data_flows), so altering them desyncs full vs
- * incremental indexing. */
+ * so CALLS edges carry their source line regardless of resolution path. Line and
+ * args here are restricted to CALLS; HTTP_CALLS / ASYNC_CALLS props are finished
+ * by the parallel formatter itself (emit_http_async_edge), because route/service
+ * edge props feed full-only predump passes (create_route_nodes /
+ * create_data_flows) and must not differ between the two passes. */
 /* Append a ,"args":[{"i":0,"e":"<expr>","v":"<value>"},...] field onto a CALLS
  * edge's JSON props (the props buffer ends in '}'). The sequential pass omitted
  * this, so data_flow mode had no argument expressions to surface for small
@@ -585,8 +586,10 @@ static void emit_http_async_edge(cbm_pipeline_ctx_t *ctx, const CBMCall *call,
      * emit_http_async_service_edge: the old single format string closed the
      * method value's quote but not the broker's, emitting
      * "broker":"bullmq} on EVERY brokered ASYNC_CALLS edge — and its fixup
-     * only handled truncation, which never fires in the normal case (#898). */
-    char props[CBM_SZ_512];
+     * only handled truncation, which never fires in the normal case (#898).
+     * The call's args and the closing brace come from the parallel path's own
+     * formatter, so a service edge is byte-identical whichever pass emits it. */
+    char props[CBM_SZ_2K];
     int n = snprintf(props, sizeof(props), "{\"callee\":\"%s\",\"url_path\":\"%s\"", esc_callee,
                      esc_url);
     if (method && n > 0 && (size_t)n < sizeof(props)) {
@@ -595,11 +598,8 @@ static void emit_http_async_edge(cbm_pipeline_ctx_t *ctx, const CBMCall *call,
     if (broker && n > 0 && (size_t)n < sizeof(props)) {
         n += snprintf(props + n, sizeof(props) - (size_t)n, ",\"broker\":\"%s\"", broker);
     }
-    if (n > 0 && (size_t)n < sizeof(props) - 1) {
-        props[n] = '}';
-        props[n + 1] = '\0';
-    }
-    calls_emit_edge(ctx->gbuf, source->id, route_id, edge_type, props, sizeof(props), call);
+    cbm_pipeline_close_call_props(props, n, call, false);
+    cbm_gbuf_insert_edge(ctx->gbuf, source->id, route_id, edge_type, props);
 }
 
 /* Classify a resolved call and emit the appropriate edge. */
@@ -671,7 +671,8 @@ static const cbm_gbuf_node_t *calls_find_source(cbm_pipeline_ctx_t *ctx, const c
 static int resolve_single_call(cbm_pipeline_ctx_t *ctx, CBMCall *call, const CBMFileResult *result,
                                const char *rel, const char *module_qn, const char **imp_keys,
                                const char **imp_vals, int imp_count, CBMLanguage lang,
-                               const CBMImportArray *imports, const char *route_mount) {
+                               const CBMImportArray *imports, const char *route_mount,
+                               const cbm_php_vendor_names_t *php_vendor) {
     const CBMResolvedCallArray *lsp_calls = &result->resolved_calls;
     const cbm_gbuf_node_t *source_node = calls_find_source(ctx, rel, call->enclosing_func_qn);
     if (!source_node) {
@@ -683,6 +684,12 @@ static int resolve_single_call(cbm_pipeline_ctx_t *ctx, CBMCall *call, const CBM
     bool allow_tail = cbm_pipeline_lsp_allow_tail_match(lang);
     const CBMResolvedCall *lsp = cbm_pipeline_find_lsp_resolution_in_graph(
         lsp_calls, call, allow_tail, ctx->gbuf, ctx->project_name);
+    /* #1186: a PHP call on a vendor type (`new Request`, or a receiver the LSP
+     * typed as an imported vendor class) takes the LSP result or no target: a
+     * same-named project symbol found by name alone is never the vendor's.
+     * Service/route classification below still runs. Mirrors pass_parallel.c. */
+    bool php_vendor_call = cbm_pipeline_php_vendor_call(php_vendor, result, call) ||
+                           cbm_pipeline_lsp_external_receiver(lsp);
     if (lsp) {
         bool exact_external_target = call->requires_lsp_resolution &&
                                      cbm_pipeline_kotlin_external_target(lang, lsp->callee_qn);
@@ -750,14 +757,19 @@ static int resolve_single_call(cbm_pipeline_ctx_t *ctx, CBMCall *call, const CBM
         emit_http_async_edge(ctx, &routed, source_node, NULL, &svc_res, CBM_SVC_HTTP, false);
         return SKIP_ONE;
     }
-    cbm_svc_kind_t csvc = cbm_service_pattern_match(call->callee_name);
+    /* A PHP call on a proven vendor class is classified by that class
+     * (#1186): it skips the registry below, so the route-verb fallback would
+     * otherwise mint a route registration for `GuzzleClient::get('/x')`. An
+     * LSP row with a graph target returned above. MUST match pass_parallel.c. */
+    cbm_svc_kind_t csvc;
+    const char *svc_name = cbm_pipeline_service_name(call, lsp, &csvc);
     if (csvc == CBM_SVC_HTTP || csvc == CBM_SVC_ASYNC) {
         const char *cu = call->first_string_arg;
         bool chas_url = cu && cu[0] != '\0' &&
                         (cu[0] == '/' || strstr(cu, "://") != NULL ||
                          (csvc == CBM_SVC_ASYNC && strlen(cu) > PAIR_LEN));
         if (chas_url) {
-            cbm_resolution_t svc_res = {.qualified_name = call->callee_name,
+            cbm_resolution_t svc_res = {.qualified_name = svc_name,
                                         .confidence = PC_SVC_PATTERN_CONF,
                                         .strategy = "service_pattern",
                                         .candidate_count = 0};
@@ -774,7 +786,7 @@ static int resolve_single_call(cbm_pipeline_ctx_t *ctx, CBMCall *call, const CBM
     bool rust_external = lsp && cbm_pipeline_rust_external_target(
                                     lang, lsp->strategy, lsp->callee_qn, ctx->project_name);
     cbm_resolution_t res = {0};
-    if (!rust_external) {
+    if (!rust_external && !php_vendor_call) {
         res = cbm_registry_resolve_lang(ctx->registry, call->callee_name, module_qn, imp_keys,
                                         imp_vals, imp_count, lang);
         /* Cross-language veto: a name-only guess never binds another
@@ -1147,6 +1159,8 @@ int cbm_pipeline_pass_calls(cbm_pipeline_ctx_t *ctx, const cbm_file_info_t *file
         const char **imp_vals = NULL;
         int imp_count = 0;
         build_import_map(ctx, rel, result, &imp_keys, &imp_vals, &imp_count);
+        cbm_php_vendor_names_t php_vendor;
+        cbm_pipeline_php_vendor_names_build(ctx->gbuf, ctx->project_name, rel, result, &php_vendor);
 
         /* Compute module QN for same-module resolution (directory-based for
          * Java/Go so it matches their def-node QNs in the registry). */
@@ -1166,14 +1180,16 @@ int cbm_pipeline_pass_calls(cbm_pipeline_ctx_t *ctx, const cbm_file_info_t *file
             }
             total_calls++;
             if (resolve_single_call(ctx, call, result, rel, module_qn, imp_keys, imp_vals,
-                                    imp_count, files[i].language, &result->imports, route_mount)) {
+                                    imp_count, files[i].language, &result->imports, route_mount,
+                                    &php_vendor)) {
                 resolved++;
             } else {
                 unresolved++;
             }
         }
 
         free(module_qn);
+        cbm_pipeline_php_vendor_names_free(&php_vendor);
         free_import_map(imp_keys, imp_vals, imp_count);
         if (result_owned) {
             cbm_free_result(result);

src/pipeline/pass_calls.c

@@ -556,20 +556,25 @@ static int create_import_edges_for_file(cbm_pipeline_ctx_t *ctx, const CBMFileRe
         free(file_qn);
         return 0;
     }
-    for (int j = 0; j < result->imports.count; j++) {
-        const CBMImport *imp = &result->imports.items[j];
-        if (!imp->module_path) {
-            continue;
-        }
-        const cbm_gbuf_node_t *target =
-            cbm_pipeline_resolve_import_node(ctx, rel, file_qn, imp, namespace_map);
-        if (target && target->id != source_node->id) {
-            char esc_ln[CBM_SZ_128];
-            cbm_json_escape(esc_ln, sizeof(esc_ln), imp->local_name ? imp->local_name : "");
-            char imp_props[CBM_SZ_256];
-            snprintf(imp_props, sizeof(imp_props), "{\"local_name\":\"%s\"}", esc_ln);
-            cbm_gbuf_insert_edge(ctx->gbuf, source_node->id, target->id, "IMPORTS", imp_props);
-            count++;
+    if (cbm_language_for_filename(rel) == CBM_LANG_PHP) {
+        count = cbm_pipeline_php_create_import_edges(ctx, result, rel, file_qn, source_node,
+                                                     namespace_map);
+    } else {
+        for (int j = 0; j < result->imports.count; j++) {
+            const CBMImport *imp = &result->imports.items[j];
+            if (!imp->module_path) {
+                continue;
+            }
+            const cbm_gbuf_node_t *target =
+                cbm_pipeline_resolve_import_node(ctx, rel, file_qn, imp, namespace_map);
+            if (target && target->id != source_node->id) {
+                char esc_ln[CBM_SZ_128];
+                cbm_json_escape(esc_ln, sizeof(esc_ln), imp->local_name ? imp->local_name : "");
+                char imp_props[CBM_SZ_256];
+                snprintf(imp_props, sizeof(imp_props), "{\"local_name\":\"%s\"}", esc_ln);
+                cbm_gbuf_insert_edge(ctx->gbuf, source_node->id, target->id, "IMPORTS", imp_props);
+                count++;
+            }
         }
     }
     free(file_qn);