Skip to content

Commit 50ee111

Browse files
fix(pipeline): suppress weak short-name matches for Go selector calls
A Go selector call x.foo() whose receiver the Go LSP cannot type falls through to the generic registry resolver, which binds it by bare short name to an arbitrary same-named project symbol. Stdlib calls are the worst case: f.Close() on an *os.File gets a CALLS edge to whatever project Close wins candidate ranking (measured on a real Go repo: confidence 0.11, 15 candidates; suffix_match + unique_name were 36% of all CALLS edges, and one 14-line stdlib-only function got 3 out of 3 false outbound edges). Extend the TS/JS receiver-aware guard (DeusData#592/DeusData#606) to Go: - extract_calls.c: flag Go call_expression with a selector_expression callee as is_method, mirroring the TS/JS member_expression flag. - registry.c: add cbm_go_suppress_weak_method_match. Unlike the TS/JS drop-list, field_type_hint is KEPT (Go struct fields carry declared types, so the hint is receiver-aware — lrp_go_s8_field_type_hint), and unique_name is dropped only when its confidence carries the import-unreachability penalty (the stdlib-hijack shape); an unpenalized lone candidate inside the caller's import closure never enters the field-type-hint upgrade and must survive. - pass_calls.c / pass_parallel.c: feed the Go gate next to the TS/JS one; the drop still defers to the emit path so service/route/HTTP edges stay main-identical. Reproduce-first: pipeline_go_receiver_suppresses_weak_method_edge is RED without the extractor flag (the f.Close -> project Close edge exists) and GREEN with it; typed same-package calls, bare local calls and import-qualified cross-package calls still resolve. The old extraction contract test used Go as the flag-exempt language — Python takes that role, and extract_go_selector_call_flags_is_method pins the new behavior. Signed-off-by: Ilya Brykau <ilya.brykau@orca.security>
1 parent 8972ea6 commit 50ee111

8 files changed

Lines changed: 242 additions & 7 deletions

File tree

‎internal/cbm/extract_calls.c‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3712,6 +3712,24 @@ CBMInvocationDescriptor handle_calls(CBMExtractCtx *ctx, TSNode node, const CBML
37123712
}
37133713
}
37143714
}
3715+
// Go receiver-aware guard (same direction as the TS/JS flag above).
3716+
// Flag a selector call x.foo(). The Go AST cannot separate a method
3717+
// call on a value from a package-qualified call — but every selector
3718+
// call the Go LSP or the import/qualified registry strategies CAN
3719+
// place never reaches the weak short-name guards, so the flag only
3720+
// bites on unresolvable receivers (`f.Close()` on an os.File,
3721+
// `sha256.New()` behind an unindexed import), where a project-wide
3722+
// short-name match fabricates an edge to an unrelated project
3723+
// symbol sharing the name. Bare calls (helper()) keep
3724+
// is_method=false and resolve same-module/import paths as before.
3725+
if (ctx->language == CBM_LANG_GO &&
3726+
strcmp(ts_node_type(node), "call_expression") == 0) {
3727+
TSNode gofn = ts_node_child_by_field_name(node, TS_FIELD("function"));
3728+
if (!ts_node_is_null(gofn) &&
3729+
strcmp(ts_node_type(gofn), "selector_expression") == 0) {
3730+
call.is_method = true;
3731+
}
3732+
}
37153733

37163734
TSNode args = ts_node_child_by_field_name(node, TS_FIELD("arguments"));
37173735
/* tree-sitter-elixir attaches NO field name to a call's arguments

‎src/pipeline/pass_calls.c‎

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -623,7 +623,13 @@ static int resolve_single_call(cbm_pipeline_ctx_t *ctx, CBMCall *call,
623623
* language gated on only one resolver produces an edge on the sequential
624624
* path and not the parallel one (or vice versa), breaking MT determinism.
625625
* ArkTS belongs to the JS/TS family here (#1842); dropping it would
626-
* reintroduce the #592/#606 false-edge class for .ets files. */
626+
* reintroduce the #592/#606 false-edge class for .ets files.
627+
*
628+
* Go (#1906) rides the same deferred-drop plumbing through its OWN
629+
* predicate: its drop-list differs (field_type_hint is receiver-aware for
630+
* Go, and unique_name drops only when import-unreachability-penalized), so
631+
* it composes via cbm_go_suppress_weak_method_match instead of widening
632+
* the shared gate. Same lockstep rule: mirror pass_parallel.c. */
627633
bool suppress_weak_member = lang == CBM_LANG_PYTHON || lang == CBM_LANG_JAVASCRIPT ||
628634
lang == CBM_LANG_TYPESCRIPT || lang == CBM_LANG_TSX ||
629635
lang == CBM_LANG_ARKTS;
@@ -636,7 +642,9 @@ static int resolve_single_call(cbm_pipeline_ctx_t *ctx, CBMCall *call,
636642
bool drop_plain_call =
637643
cbm_suppress_weak_member_match(suppress_weak_member, call->is_method, res.strategy) ||
638644
cbm_suppress_weak_local_binding_call(suppress_weak_local_binding,
639-
call->callee_is_locally_bound, res.strategy);
645+
call->callee_is_locally_bound, res.strategy) ||
646+
cbm_go_suppress_weak_method_match(lang == CBM_LANG_GO, call->is_method, res.strategy,
647+
res.confidence);
640648

641649
/* Service-pattern HTTP/ASYNC calls to an EXTERNAL client library (e.g.
642650
* `requests.get("/api/orders/{id}")`) resolve to a QN containing the library

‎src/pipeline/pass_parallel.c‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2834,7 +2834,9 @@ static void resolve_file_calls(resolve_ctx_t *rc, resolve_worker_state_t *ws, CB
28342834
* #606 direction.
28352835
*
28362836
* This language set MUST match the one in pass_calls.c exactly — see the
2837-
* note there. ArkTS belongs to the JS/TS family (#1842). */
2837+
* note there. ArkTS belongs to the JS/TS family (#1842). Go (#1906)
2838+
* composes via its own predicate (different drop-list — see
2839+
* cbm_go_suppress_weak_method_match), mirrored in pass_calls.c. */
28382840
bool suppress_weak_member = lang == CBM_LANG_PYTHON || lang == CBM_LANG_JAVASCRIPT ||
28392841
lang == CBM_LANG_TYPESCRIPT || lang == CBM_LANG_TSX ||
28402842
lang == CBM_LANG_ARKTS;
@@ -2844,7 +2846,9 @@ static void resolve_file_calls(resolve_ctx_t *rc, resolve_worker_state_t *ws, CB
28442846
bool drop_plain_call =
28452847
cbm_suppress_weak_member_match(suppress_weak_member, call->is_method, res.strategy) ||
28462848
cbm_suppress_weak_local_binding_call(suppress_weak_local_binding,
2847-
call->callee_is_locally_bound, res.strategy);
2849+
call->callee_is_locally_bound, res.strategy) ||
2850+
cbm_go_suppress_weak_method_match(lang == CBM_LANG_GO, call->is_method, res.strategy,
2851+
res.confidence);
28482852

28492853
/* Service-pattern HTTP/ASYNC client call (`requests.get(url)`): the
28502854
* service signal lives in the callee_name. The registry can mis-resolve

‎src/pipeline/pipeline.h‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -297,6 +297,15 @@ bool cbm_suppress_weak_member_match(bool enabled, bool is_method, const char *st
297297
bool cbm_suppress_weak_local_binding_call(bool enabled, bool callee_is_locally_bound,
298298
const char *strategy);
299299

300+
/* Go analog of the TS/JS guard, same failure class: a selector call whose
301+
* receiver the Go LSP could not type must not be bound by a receiver-blind
302+
* short-name strategy. Drops suffix_match / fuzzy always, and unique_name only
303+
* when its confidence is import-unreachability-penalized (the stdlib/vendor
304+
* hijack shape). field_type_hint is deliberately NOT dropped for Go — struct
305+
* fields carry declared types, so the hint is receiver-aware there. */
306+
bool cbm_go_suppress_weak_method_match(bool is_go, bool is_method, const char *strategy,
307+
double confidence);
308+
300309
/* #725: drop a suffix_match CALLS edge when the caller language and the
301310
* target file's language disagree. unique_name (candidates == 1) is #1572
302311
* and is left alone; same_module / import_map / lsp_* are kept. JS/TS/TSX

‎src/pipeline/registry.c‎

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -501,6 +501,33 @@ bool cbm_suppress_weak_local_binding_call(bool enabled, bool callee_is_locally_b
501501
return weak_short_name_strategy(strategy);
502502
}
503503

504+
bool cbm_go_suppress_weak_method_match(bool is_go, bool is_method, const char *strategy,
505+
double confidence) {
506+
if (!is_go || !is_method || !strategy || !strategy[0]) {
507+
return false;
508+
}
509+
/* Go analog of the TS/JS guard above, same failure class: a selector call
510+
* whose receiver the Go LSP could not type reaches the registry and a bare
511+
* short-name strategy binds it to an arbitrary same-named project symbol
512+
* (`f.Close()` on an os.File -> a project `Close`, suffix_match over 15
513+
* candidates). Unlike the TS/JS list, field_type_hint is KEPT: a Go struct
514+
* field carries a declared type, so the parallel resolver's field-type
515+
* hint is receiver-aware for Go (lrp_go_s8_field_type_hint), not a
516+
* heuristic. */
517+
if (strcmp(strategy, "suffix_match") == 0 || strcmp(strategy, "fuzzy") == 0) {
518+
return true;
519+
}
520+
/* unique_name is dropped only when PENALIZED: resolve_name_lookup scales
521+
* CONF_UNIQUE_NAME by DEFAULT_CONFIDENCE exactly when the lone candidate
522+
* is not reachable through the caller's imports — the stdlib/vendor
523+
* hijack shape (`io.Copy` -> a project `Copy`). An unpenalized
524+
* unique_name target sits inside the caller's import closure (or the
525+
* file has no imports, e.g. a same-package call) and must be kept —
526+
* dropping it kills genuinely-typed lone-candidate calls that never
527+
* enter the field-type-hint upgrade (candidate_count == 1). */
528+
return strcmp(strategy, "unique_name") == 0 && confidence < CONF_UNIQUE_NAME;
529+
}
530+
504531
static bool js_ts_family(CBMLanguage lang) {
505532
return lang == CBM_LANG_JAVASCRIPT || lang == CBM_LANG_TYPESCRIPT || lang == CBM_LANG_TSX ||
506533
lang == CBM_LANG_ARKTS;

‎tests/test_extraction.c‎

Lines changed: 36 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5204,9 +5204,14 @@ TEST(extract_perl_method_call_flags_is_method) {
52045204
/* Languages OUTSIDE the is_method flag set (only Perl and TS/JS/TSX set it) must
52055205
* be unaffected: a Go method call never sets is_method. */
52065206
TEST(extract_flag_exempt_method_call_not_flagged_is_method) {
5207-
CBMFileResult *r = extract("package m\n"
5208-
"func run(o Obj) { o.Commit(); helper() }\n",
5209-
CBM_LANG_GO, "t", "x.go");
5207+
/* Rust is flag-exempt: only Perl, Python, TS/JS and Go set is_method.
5208+
* Guards the blast radius of the receiver-aware flags for every other
5209+
* language. */
5210+
CBMFileResult *r = extract("fn run(o: Obj) {\n"
5211+
" o.commit();\n"
5212+
" helper();\n"
5213+
"}\n",
5214+
CBM_LANG_RUST, "t", "x.rs");
52105215
ASSERT_NOT_NULL(r);
52115216
ASSERT_FALSE(r->has_error);
52125217
for (int i = 0; i < r->calls.count; i++) {
@@ -5364,6 +5369,33 @@ TEST(extract_python_bare_call_flags_locally_bound_callee) {
53645369
PASS();
53655370
}
53665371

5372+
TEST(extract_go_selector_call_flags_is_method) {
5373+
/* Go selector calls are flagged so the weak-match guard can fire when the
5374+
* Go LSP cannot type the receiver; bare calls stay unflagged. */
5375+
CBMFileResult *r = extract("package m\n"
5376+
"func run(o Obj) { o.Commit(); helper() }\n",
5377+
CBM_LANG_GO, "t", "x.go");
5378+
ASSERT_NOT_NULL(r);
5379+
ASSERT_FALSE(r->has_error);
5380+
bool saw_selector = false;
5381+
bool saw_bare = false;
5382+
for (int i = 0; i < r->calls.count; i++) {
5383+
const CBMCall *c = &r->calls.items[i];
5384+
if (c->callee_name && strstr(c->callee_name, "Commit") != NULL) {
5385+
ASSERT_TRUE(c->is_method);
5386+
saw_selector = true;
5387+
}
5388+
if (c->callee_name && strcmp(c->callee_name, "helper") == 0) {
5389+
ASSERT_FALSE(c->is_method);
5390+
saw_bare = true;
5391+
}
5392+
}
5393+
ASSERT_TRUE(saw_selector);
5394+
ASSERT_TRUE(saw_bare);
5395+
cbm_free_result(r);
5396+
PASS();
5397+
}
5398+
53675399
/* The bare-call flag is DEPTH-INDEPENDENT, and the binding is UNWOUND when its
53685400
* scope closes.
53695401
*
@@ -7508,6 +7540,7 @@ SUITE(extraction) {
75087540
RUN_TEST(extract_python_member_call_flags_is_method);
75097541
RUN_TEST(extract_python_bare_call_flags_locally_bound_callee);
75107542
RUN_TEST(extract_python_bare_call_flag_is_depth_independent);
7543+
RUN_TEST(extract_go_selector_call_flags_is_method);
75117544
RUN_TEST(extract_ts_member_call_flags_is_method);
75127545
RUN_TEST(extract_ts_this_super_receiver_not_flagged);
75137546
RUN_TEST(extract_js_member_call_flags_is_method);

‎tests/test_pipeline.c‎

Lines changed: 94 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5467,6 +5467,99 @@ TEST(pipeline_python_receiver_suppresses_weak_method_edge) {
54675467
PASS();
54685468
}
54695469

5470+
TEST(pipeline_go_receiver_suppresses_weak_method_edge) {
5471+
char tmp[256];
5472+
snprintf(tmp, sizeof(tmp), "/tmp/cbm_go_recv_XXXXXX");
5473+
if (!cbm_mkdtemp(tmp)) {
5474+
FAIL("tmpdir");
5475+
}
5476+
5477+
/* go.mod makes project imports resolvable — real Go repos always have one,
5478+
* and import reachability (the unique_name penalty) depends on it. */
5479+
write_temp_file(tmp, "go.mod", "module example.com/myapp\n\ngo 1.22\n");
5480+
/* The lone project symbol named "Close" — a real method. */
5481+
write_temp_file(tmp, "storage/storage.go",
5482+
"package storage\n"
5483+
"\n"
5484+
"type Storage struct{ open bool }\n"
5485+
"\n"
5486+
"func NewStorage() *Storage { return &Storage{open: true} }\n"
5487+
"\n"
5488+
"func (s *Storage) Close() {\n"
5489+
"\ts.open = false\n"
5490+
"}\n"
5491+
"\n"
5492+
"func Boot() {\n"
5493+
"\ts := NewStorage()\n"
5494+
"\ts.Close()\n"
5495+
"}\n");
5496+
/* Cross-package control target: imported by hash.go, so the caller file
5497+
* has a non-empty import map (like any real Go file) and unreachable
5498+
* unique_name candidates get the import penalty. */
5499+
write_temp_file(tmp, "util/util.go",
5500+
"package util\n"
5501+
"\n"
5502+
"func Tag() string { return \"t\" }\n");
5503+
/* Stdlib receiver: `f.Close()` closes an *os.File, NOT the project method.
5504+
* The Go LSP cannot bind it to a project symbol → the registry would guess
5505+
* Close by short name (weak). This is the false edge to suppress —
5506+
* the exact shape that attached every file/rows/gzip Close in a real Go
5507+
* repo to one unrelated project method. */
5508+
write_temp_file(tmp, "hash/hash.go",
5509+
"package hash\n"
5510+
"\n"
5511+
"import (\n"
5512+
"\t\"os\"\n"
5513+
"\n"
5514+
"\t\"example.com/myapp/util\"\n"
5515+
")\n"
5516+
"\n"
5517+
"func FileLen(path string) int64 {\n"
5518+
"\tf, err := os.Open(path)\n"
5519+
"\tif err != nil {\n"
5520+
"\t\treturn 0\n"
5521+
"\t}\n"
5522+
"\tdefer f.Close()\n"
5523+
"\tst, err := f.Stat()\n"
5524+
"\tif err != nil {\n"
5525+
"\t\treturn 0\n"
5526+
"\t}\n"
5527+
"\treturn st.Size()\n"
5528+
"}\n"
5529+
"\n"
5530+
"func localHelper() int { return 1 }\n"
5531+
"\n"
5532+
"func CallsLocal() int { return localHelper() }\n"
5533+
"\n"
5534+
"func UsesUtil() string { return util.Tag() }\n");
5535+
5536+
char db_path[512];
5537+
snprintf(db_path, sizeof(db_path), "%s/go_recv.db", tmp);
5538+
cbm_pipeline_t *p = cbm_pipeline_new(tmp, db_path, CBM_MODE_FULL);
5539+
ASSERT_NOT_NULL(p);
5540+
ASSERT_EQ(cbm_pipeline_run(p), 0);
5541+
const char *project = cbm_pipeline_project_name(p);
5542+
5543+
cbm_store_t *s = cbm_store_open_path(db_path);
5544+
ASSERT_NOT_NULL(s);
5545+
5546+
/* (1) The false edge is suppressed (reproduce-first: RED before the fix). */
5547+
ASSERT_FALSE(cross_file_call_exists(s, project, "FileLen", "Close"));
5548+
/* (2) The same-package typed-receiver call survives (LSP / same_module —
5549+
* both outside the weak drop-list). */
5550+
ASSERT_TRUE(cross_file_call_exists(s, project, "Boot", "Close"));
5551+
/* (3) The bare local call survives (is_method stays false for bare calls). */
5552+
ASSERT_TRUE(cross_file_call_exists(s, project, "CallsLocal", "localHelper"));
5553+
/* (4) The import-qualified cross-package call survives (import-aware
5554+
* strategies are outside the drop-list). */
5555+
ASSERT_TRUE(cross_file_call_exists(s, project, "UsesUtil", "Tag"));
5556+
5557+
cbm_store_close(s);
5558+
cbm_pipeline_free(p);
5559+
th_rmtree(tmp);
5560+
PASS();
5561+
}
5562+
54705563
/* Fixture for the #1928 cross-language reference-guard probes (sequential and
54715564
* parallel twins). pad_files > 0 adds filler files to push the index over the
54725565
* parallel-pipeline threshold, since USAGE/WRITES/READS have one resolver per
@@ -14594,6 +14687,7 @@ SUITE(pipeline) {
1459414687
#endif
1459514688
RUN_TEST(pipeline_tsjs_receiver_suppresses_weak_method_edge);
1459614689
RUN_TEST(pipeline_python_receiver_suppresses_weak_method_edge);
14690+
RUN_TEST(pipeline_go_receiver_suppresses_weak_method_edge);
1459714691
RUN_TEST(pipeline_go_rw_usage_never_cross_into_c);
1459814692
RUN_TEST(pipeline_go_rw_usage_never_cross_into_c_parallel);
1459914693
RUN_TEST(pipeline_go_bare_ref_never_binds_field);

‎tests/test_registry.c‎

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -973,6 +973,46 @@ TEST(weak_call_guards_share_one_drop_list) {
973973
PASS();
974974
}
975975

976+
TEST(go_suppress_drops_weak_selector_matches) {
977+
/* Go selector call with an untyped receiver, landed via a receiver-blind
978+
* short-name strategy → drop (same failure class as #592/#606).
979+
* suffix_match/fuzzy drop at any confidence; unique_name drops only when
980+
* import-unreachability-penalized (CONF_UNIQUE_NAME 0.75 * 0.5 = 0.375 —
981+
* the `io.Copy` -> project `Copy` stdlib-hijack shape). */
982+
ASSERT_TRUE(cbm_go_suppress_weak_method_match(true, true, "suffix_match", 0.9));
983+
ASSERT_TRUE(cbm_go_suppress_weak_method_match(true, true, "suffix_match", 0.11));
984+
ASSERT_TRUE(cbm_go_suppress_weak_method_match(true, true, "fuzzy", 0.9));
985+
ASSERT_TRUE(cbm_go_suppress_weak_method_match(true, true, "unique_name", 0.375));
986+
PASS();
987+
}
988+
989+
TEST(go_suppress_keeps_typed_and_import_aware_matches) {
990+
/* Unpenalized unique_name = lone candidate inside the caller's import
991+
* closure (or an import-free file, e.g. same-package) — a genuinely-typed
992+
* lone-candidate call never enters the field-type-hint upgrade, so it must
993+
* survive (lrp_go_s8_field_type_hint). */
994+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, true, "unique_name", 0.75));
995+
/* field_type_hint is receiver-aware for Go — struct fields carry declared
996+
* types (lrp_go_s8_field_type_hint) — so it stays, unlike the TS/JS list. */
997+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, true, "field_type_hint", 0.85));
998+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, true, "same_module", 0.9));
999+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, true, "import_map", 0.95));
1000+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, true, "import_map_suffix", 0.9));
1001+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, true, "qualified_suffix", 0.9));
1002+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, true, "callee_suffix", 0.5));
1003+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, true, "service_pattern", 0.5));
1004+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, true, "lsp_strategy_cross_file", 0.92));
1005+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, true, "lsp_direct", 0.95));
1006+
/* A bare call (is_method=false) is a free-function call → never suppressed. */
1007+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, false, "suffix_match", 0.11));
1008+
/* Non-Go languages are never affected by this gate. */
1009+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(false, true, "suffix_match", 0.11));
1010+
/* No match (NULL/empty strategy) → nothing to suppress. */
1011+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, true, NULL, 0.5));
1012+
ASSERT_FALSE(cbm_go_suppress_weak_method_match(true, true, "", 0.5));
1013+
PASS();
1014+
}
1015+
9761016
/* ── Suite ─────────────────────────────────────────────────────── */
9771017

9781018
/* Method call THROUGH an imported symbol that is itself an indexed node
@@ -1072,4 +1112,6 @@ SUITE(registry) {
10721112
RUN_TEST(local_binding_suppress_drops_weak_shadowed_bare_calls);
10731113
RUN_TEST(local_binding_suppress_keeps_unshadowed_and_strong_strategies);
10741114
RUN_TEST(weak_call_guards_share_one_drop_list);
1115+
RUN_TEST(go_suppress_drops_weak_selector_matches);
1116+
RUN_TEST(go_suppress_keeps_typed_and_import_aware_matches);
10751117
}

0 commit comments

Comments
 (0)