/* Production-graph contracts for callable values. These tests intentionally * exercise the full MCP indexing path rather than only raw extraction/LSP rows. */ #include "test_framework.h" #include "repro_harness.h" #include #include static int crc_edge_count(cbm_store_t *store, const char *project, const char *type, const char *source_name, const char *target_label, const char *target_name) { cbm_edge_t *edges = NULL; int edge_count = 0; if (cbm_store_find_edges_by_type(store, project, type, &edges, &edge_count) != CBM_STORE_OK) { return -1; } int matches = 0; for (int i = 0; i < edge_count; i++) { cbm_node_t source = {0}; cbm_node_t target = {0}; bool source_ok = cbm_store_find_node_by_id(store, edges[i].source_id, &source) == CBM_STORE_OK; bool target_ok = cbm_store_find_node_by_id(store, edges[i].target_id, &target) == CBM_STORE_OK; if (source_ok && target_ok && source.name && target.name && strcmp(source.name, source_name) == 0 && strcmp(target.name, target_name) == 0 && (!target_label || (target.label && strcmp(target.label, target_label) == 0))) { matches++; } cbm_node_free_fields(&source); cbm_node_free_fields(&target); } cbm_store_free_edges(edges, edge_count); return matches; } /* Edges of `type` out of `source_name` whose target's qualified name ends with * `target_qn_suffix`. Two methods in one project can share a short name, and * then only the qualified name tells them apart. */ static int crc_edge_count_to_qn(cbm_store_t *store, const char *project, const char *type, const char *source_name, const char *target_qn_suffix) { cbm_edge_t *edges = NULL; int edge_count = 0; if (cbm_store_find_edges_by_type(store, project, type, &edges, &edge_count) != CBM_STORE_OK) { return -1; } int matches = 0; size_t suffix_len = strlen(target_qn_suffix); for (int i = 0; i < edge_count; i++) { cbm_node_t source = {0}; cbm_node_t target = {0}; bool source_ok = cbm_store_find_node_by_id(store, edges[i].source_id, &source) == CBM_STORE_OK; bool target_ok = cbm_store_find_node_by_id(store, edges[i].target_id, &target) == CBM_STORE_OK; if (source_ok && target_ok && source.name && target.qualified_name && strcmp(source.name, source_name) == 0) { size_t qn_len = strlen(target.qualified_name); if (qn_len >= suffix_len && strcmp(target.qualified_name + qn_len - suffix_len, target_qn_suffix) == 0) { matches++; } } cbm_node_free_fields(&source); cbm_node_free_fields(&target); } cbm_store_free_edges(edges, edge_count); return matches; } static int crc_global_handler_edge_count(cbm_store_t *store, const char *project, const char *caller) { int references = crc_edge_count(store, project, "CALL_REFERENCE", caller, "Function", "handler"); int calls = crc_edge_count(store, project, "CALLS", caller, "Function", "handler"); int usages = crc_edge_count(store, project, "USAGE", caller, "Function", "handler"); return references < 0 || calls < 0 || usages < 0 ? -1 : references + calls + usages; } static int crc_function_count(cbm_store_t *store, const char *project, const char *name) { cbm_node_t *nodes = NULL; int node_count = 0; if (cbm_store_find_nodes_by_name(store, project, name, &nodes, &node_count) != CBM_STORE_OK) { return -1; } int functions = 0; for (int i = 0; i < node_count; i++) { if (nodes[i].label && strcmp(nodes[i].label, "Function") == 0) { functions++; } } cbm_store_free_nodes(nodes, node_count); return functions; } TEST(call_reference_typescript_direct_argument_is_exact) { static const char source[] = "function handler(): void {}\n" "function register(callback: () => void): void {}\n" "function bootstrap(): void { register(handler); }\n"; RProj project; cbm_store_t *store = rh_index(&project, "main.ts", source); ASSERT_NOT_NULL(store); int registrar = crc_edge_count(store, project.project, "CALLS", "bootstrap", "Function", "register"); int reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "bootstrap", "Function", "handler"); int usage = crc_edge_count(store, project.project, "USAGE", "bootstrap", "Function", "handler"); int fabricated_call = crc_edge_count(store, project.project, "CALLS", "bootstrap", "Function", "handler"); rh_cleanup(&project, store); ASSERT_EQ(registrar, 1); ASSERT_EQ(reference, 1); ASSERT_EQ(usage, 0); ASSERT_EQ(fabricated_call, 0); PASS(); } TEST(call_reference_kotlin_alias_argument_is_exact) { static const char source[] = "fun handler(): Unit {}\n" "fun accept(callback: () -> Unit): Unit {}\n" "val callback: () -> Unit = ::handler\n" "fun argument(): Unit {\n" " accept(callback)\n" "}\n"; RProj project; cbm_store_t *store = rh_index(&project, "AliasArgument.kt", source); ASSERT_NOT_NULL(store); int reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "argument", "Function", "handler"); int usage = crc_edge_count(store, project.project, "USAGE", "argument", "Function", "handler"); int fabricated_call = crc_edge_count(store, project.project, "CALLS", "argument", "Function", "handler"); rh_cleanup(&project, store); ASSERT_EQ(reference, 1); ASSERT_EQ(usage, 0); ASSERT_EQ(fabricated_call, 0); PASS(); } TEST(call_reference_python_use_before_local_shadow_is_not_global) { static const char source[] = "def handler():\n" " pass\n" "def accept(callback):\n" " pass\n" "def caller():\n" " accept(handler)\n" " handler = lambda: None\n"; RProj project; cbm_store_t *store = rh_index(&project, "shadow.py", source); ASSERT_NOT_NULL(store); int registrar = crc_edge_count(store, project.project, "CALLS", "caller", "Function", "accept"); int handler_nodes = crc_function_count(store, project.project, "handler"); int global_edges = crc_global_handler_edge_count(store, project.project, "caller"); rh_cleanup(&project, store); ASSERT_EQ(registrar, 1); ASSERT_GTE(handler_nodes, 1); ASSERT_EQ(global_edges, 0); PASS(); } TEST(call_reference_javascript_use_before_local_shadow_is_not_global) { static const char source[] = "function handler() {}\n" "function accept(callback) {}\n" "function caller() {\n" " accept(handler);\n" " const handler = () => {};\n" "}\n"; RProj project; cbm_store_t *store = rh_index(&project, "shadow.js", source); ASSERT_NOT_NULL(store); int registrar = crc_edge_count(store, project.project, "CALLS", "caller", "Function", "accept"); int handler_nodes = crc_function_count(store, project.project, "handler"); int global_edges = crc_global_handler_edge_count(store, project.project, "caller"); rh_cleanup(&project, store); ASSERT_EQ(registrar, 1); ASSERT_GTE(handler_nodes, 1); ASSERT_EQ(global_edges, 0); PASS(); } TEST(call_reference_typescript_use_before_local_shadow_is_not_global) { static const char source[] = "function handler(): void {}\n" "function accept(callback: () => void): void {}\n" "function caller(): void {\n" " accept(handler);\n" " const handler = (): void => {};\n" "}\n"; RProj project; cbm_store_t *store = rh_index(&project, "shadow.ts", source); ASSERT_NOT_NULL(store); int registrar = crc_edge_count(store, project.project, "CALLS", "caller", "Function", "accept"); int handler_nodes = crc_function_count(store, project.project, "handler"); int global_edges = crc_global_handler_edge_count(store, project.project, "caller"); rh_cleanup(&project, store); ASSERT_EQ(registrar, 1); ASSERT_GTE(handler_nodes, 1); ASSERT_EQ(global_edges, 0); PASS(); } TEST(call_reference_python_keyword_argument_is_exact) { static const char source[] = "def handler():\n" " pass\n" "def accept(callback=None):\n" " pass\n" "def argument():\n" " accept(callback=handler)\n"; RProj project; cbm_store_t *store = rh_index(&project, "keyword.py", source); ASSERT_NOT_NULL(store); int reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "argument", "Function", "handler"); int usage = crc_edge_count(store, project.project, "USAGE", "argument", "Function", "handler"); int fabricated_call = crc_edge_count(store, project.project, "CALLS", "argument", "Function", "handler"); rh_cleanup(&project, store); ASSERT_EQ(reference, 1); ASSERT_EQ(usage, 0); ASSERT_EQ(fabricated_call, 0); PASS(); } TEST(call_reference_python_bound_method_argument_is_exact) { static const char source[] = "class Service:\n" " def handler(self):\n" " pass\n" "def accept(callback):\n" " pass\n" "def argument(service: Service):\n" " accept(service.handler)\n"; RProj project; cbm_store_t *store = rh_index(&project, "bound.py", source); ASSERT_NOT_NULL(store); int reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "argument", "Method", "handler"); int usage = crc_edge_count(store, project.project, "USAGE", "argument", "Method", "handler"); int fabricated_call = crc_edge_count(store, project.project, "CALLS", "argument", "Method", "handler"); rh_cleanup(&project, store); ASSERT_EQ(reference, 1); ASSERT_EQ(usage, 0); ASSERT_EQ(fabricated_call, 0); PASS(); } TEST(call_reference_python_parenthesized_bound_method_is_exact) { static const char source[] = "class Service:\n" " def handler(self):\n" " pass\n" "def accept(callback):\n" " pass\n" "def argument(service: Service):\n" " accept((service.handler))\n"; RProj project; cbm_store_t *store = rh_index(&project, "parenthesized.py", source); ASSERT_NOT_NULL(store); int reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "argument", "Method", "handler"); int usage = crc_edge_count(store, project.project, "USAGE", "argument", "Method", "handler"); int fabricated_call = crc_edge_count(store, project.project, "CALLS", "argument", "Method", "handler"); rh_cleanup(&project, store); ASSERT_EQ(reference, 1); ASSERT_EQ(usage, 0); ASSERT_EQ(fabricated_call, 0); PASS(); } TEST(call_reference_python_instance_field_shadow_is_not_method) { static const char source[] = "class Service:\n" " def __init__(self):\n" " self.handler = 42\n" " def handler(self):\n" " pass\n" "def accept(callback):\n" " pass\n" "def argument(service: Service):\n" " accept(service.handler)\n"; RProj project; cbm_store_t *store = rh_index(&project, "field_shadow.py", source); ASSERT_NOT_NULL(store); int method_reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "argument", "Method", "handler"); int any_reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "argument", NULL, "handler"); int usage = crc_edge_count(store, project.project, "USAGE", "argument", NULL, "handler"); int fabricated_call = crc_edge_count(store, project.project, "CALLS", "argument", NULL, "handler"); rh_cleanup(&project, store); ASSERT_EQ(method_reference, 0); ASSERT_EQ(any_reference, 0); ASSERT_EQ(usage, 1); ASSERT_EQ(fabricated_call, 0); PASS(); } TEST(call_reference_python_property_value_stays_usage) { static const char source[] = "class Service:\n" " @property\n" " def handler(self) -> int:\n" " return 42\n" "def accept(callback):\n" " pass\n" "def argument(service: Service):\n" " accept(service.handler)\n"; RProj project; cbm_store_t *store = rh_index(&project, "property.py", source); ASSERT_NOT_NULL(store); int accept_call = crc_edge_count(store, project.project, "CALLS", "argument", "Function", "accept"); int reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "argument", NULL, "handler"); int usage = crc_edge_count(store, project.project, "USAGE", "argument", "Method", "handler"); int fabricated_call = crc_edge_count(store, project.project, "CALLS", "argument", NULL, "handler"); rh_cleanup(&project, store); ASSERT_EQ(accept_call, 1); ASSERT_EQ(reference, 0); ASSERT_EQ(usage, 1); ASSERT_EQ(fabricated_call, 0); PASS(); } TEST(call_reference_python_unknown_decorated_value_stays_usage) { static const char source[] = "def replace_with_value(function):\n" " return 42\n" "class Service:\n" " @replace_with_value\n" " def handler(self):\n" " pass\n" "def accept(callback):\n" " pass\n" "def argument(service: Service):\n" " accept(service.handler)\n"; RProj project; cbm_store_t *store = rh_index(&project, "unknown_decorator.py", source); ASSERT_NOT_NULL(store); int accept_call = crc_edge_count(store, project.project, "CALLS", "argument", "Function", "accept"); int reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "argument", NULL, "handler"); int usage = crc_edge_count(store, project.project, "USAGE", "argument", "Method", "handler"); int fabricated_call = crc_edge_count(store, project.project, "CALLS", "argument", NULL, "handler"); rh_cleanup(&project, store); ASSERT_EQ(accept_call, 1); ASSERT_EQ(reference, 0); ASSERT_EQ(usage, 1); ASSERT_EQ(fabricated_call, 0); PASS(); } TEST(call_reference_python_later_decorated_function_rebinding_stays_usage) { static const char source[] = "def handler():\n" " pass\n" "def replace_with_value(function):\n" " return 42\n" "@replace_with_value\n" "def handler():\n" " pass\n" "def accept(callback):\n" " pass\n" "def argument():\n" " accept(handler)\n"; RProj project; cbm_store_t *store = rh_index(&project, "function_rebinding.py", source); ASSERT_NOT_NULL(store); int accept_call = crc_edge_count(store, project.project, "CALLS", "argument", "Function", "accept"); int reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "argument", NULL, "handler"); int usage = crc_edge_count(store, project.project, "USAGE", "argument", "Function", "handler"); int fabricated_call = crc_edge_count(store, project.project, "CALLS", "argument", NULL, "handler"); rh_cleanup(&project, store); ASSERT_EQ(accept_call, 1); ASSERT_EQ(reference, 0); ASSERT_EQ(usage, 1); ASSERT_EQ(fabricated_call, 0); PASS(); } TEST(call_reference_python_later_decorated_method_rebinding_stays_usage) { static const char source[] = "def replace_with_value(function):\n" " return 42\n" "class Service:\n" " def handler(self):\n" " pass\n" " @replace_with_value\n" " def handler(self):\n" " pass\n" "def accept(callback):\n" " pass\n" "def argument(service: Service):\n" " accept(service.handler)\n"; RProj project; cbm_store_t *store = rh_index(&project, "method_rebinding.py", source); ASSERT_NOT_NULL(store); int accept_call = crc_edge_count(store, project.project, "CALLS", "argument", "Function", "accept"); int reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "argument", NULL, "handler"); int usage = crc_edge_count(store, project.project, "USAGE", "argument", "Method", "handler"); int fabricated_call = crc_edge_count(store, project.project, "CALLS", "argument", NULL, "handler"); rh_cleanup(&project, store); ASSERT_EQ(accept_call, 1); ASSERT_EQ(reference, 0); ASSERT_EQ(usage, 1); ASSERT_EQ(fabricated_call, 0); PASS(); } TEST(call_reference_go_bound_method_argument_is_exact) { static const char source[] = "package refs\n" "type Service struct{}\n" "func (Service) handler() {}\n" "func accept(callback func()) {}\n" "func argument(service Service) { accept(service.handler) }\n"; RProj project; cbm_store_t *store = rh_index(&project, "bound.go", source); ASSERT_NOT_NULL(store); int reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "argument", "Method", "handler"); int usage = crc_edge_count(store, project.project, "USAGE", "argument", "Method", "handler"); int fabricated_call = crc_edge_count(store, project.project, "CALLS", "argument", "Method", "handler"); rh_cleanup(&project, store); ASSERT_EQ(reference, 1); ASSERT_EQ(usage, 0); ASSERT_EQ(fabricated_call, 0); PASS(); } TEST(call_reference_go_ambiguous_promoted_method_stays_usage) { static const char source[] = "package refs\n" "type Alpha struct{}\n" "func (Alpha) handler() {}\n" "type Beta struct{}\n" "func (Beta) handler() {}\n" "type Service struct { Alpha; Beta }\n" "func accept(callback func()) {}\n" "func argument(service Service) { accept(service.handler) }\n"; RProj project; cbm_store_t *store = rh_index(&project, "ambiguous.go", source); ASSERT_NOT_NULL(store); int reference = crc_edge_count(store, project.project, "CALL_REFERENCE", "argument", "Method", "handler"); int usage = crc_edge_count(store, project.project, "USAGE", "argument", "Method", "handler"); int fabricated_call = crc_edge_count(store, project.project, "CALLS", "argument", "Method", "handler"); rh_cleanup(&project, store); ASSERT_EQ(reference, 0); ASSERT_EQ(usage, 1); ASSERT_EQ(fabricated_call, 0); PASS(); } TEST(call_java_record_accessor_binds_the_record) { /* A record's accessors are implicit, so `record Point(double x, ...)` * declares no `x()` in its source. Extraction emits them, and `other.x()` * binds to the record's own accessor. * * Two things must not happen instead. The call must not reach the * project-wide short-name registry and land on the first `x` in the tree — * here an unrelated class's private field. And the guard that refuses such * data binds must not swallow a real method that merely shares the * spelling: the builder's `x(int)`, declared beside its own `x` field, * keeps its edge. */ static const RFile files[] = { {"Point.java", "package com.example;\n" "public record Point(double x, double y, double z) {\n" " public double first(Point other) {\n" " return Maths.abs(other.x()) + new Builder().x(5).made();\n" " }\n" "}\n"}, {"Spring.java", "package com.example;\n" "public final class Spring {\n" " private double x;\n" " public void put(double v) { this.x = v; }\n" "}\n"}, {"Builder.java", "package com.example;\n" "public final class Builder {\n" " private int x;\n" " public Builder x(int v) { this.x = v; return this; }\n" " public int made() { return x; }\n" "}\n"}, {"Maths.java", "package com.example;\n" "public final class Maths {\n" " public static double abs(double v) { return v < 0 ? -v : v; }\n" "}\n"}}; RProj project; cbm_store_t *store = rh_index_files(&project, files, 4); ASSERT_NOT_NULL(store); int fabricated_field = crc_edge_count(store, project.project, "CALLS", "first", "Field", "x"); int fabricated_var = crc_edge_count(store, project.project, "CALLS", "first", "Variable", "x"); int genuine = crc_edge_count(store, project.project, "CALLS", "first", "Method", "abs"); int accessor = crc_edge_count_to_qn(store, project.project, "CALLS", "first", ".Point.x"); int builder = crc_edge_count_to_qn(store, project.project, "CALLS", "first", ".Builder.x"); rh_cleanup(&project, store); ASSERT_EQ(fabricated_field, 0); ASSERT_EQ(fabricated_var, 0); ASSERT_EQ(genuine, 1); ASSERT_EQ(accessor, 1); ASSERT_EQ(builder, 1); PASS(); } /* Static imports can name both an inherited method and a field. Thread's * activeCount() is external to this project, whereas Owner.activeCount is * local data; an unresolved import must not turn the field into a callee. */ static int crc_java_static_import_data_call_count(bool parallel) { RFile files[52] = {{"example/Owner.java", "package example;\n" "public class Owner extends Thread {\n" " public static int activeCount;\n" "}\n"}, {"example/Caller.java", "package example;\n" "import static example.Owner.activeCount;\n" "class Caller {\n" " int caller() { return activeCount(); }\n" "}\n"}}; char names[50][64]; char sources[50][64]; int count = parallel ? 52 : 2; for (int i = 2; i < count; i++) { snprintf(names[i - 2], sizeof(names[i - 2]), "example/Pad%d.java", i); snprintf(sources[i - 2], sizeof(sources[i - 2]), "package example; class Pad%d {}\n", i); files[i].name = names[i - 2]; files[i].content = sources[i - 2]; } RProj project; cbm_store_t *store = rh_index_files(&project, files, count); if (!store) { return -1; } int fields = crc_edge_count(store, project.project, "CALLS", "caller", "Field", "activeCount"); int vars = crc_edge_count(store, project.project, "CALLS", "caller", "Variable", "activeCount"); rh_cleanup(&project, store); return fields < 0 || vars < 0 ? -1 : fields + vars; } TEST(call_java_static_import_does_not_call_field_sequential) { ASSERT_EQ(crc_java_static_import_data_call_count(false), 0); PASS(); } TEST(call_java_static_import_does_not_call_field_parallel) { ASSERT_EQ(crc_java_static_import_data_call_count(true), 0); PASS(); } TEST(call_java_record_varargs_accessor_has_array_return) { static const char *sources[] = { "record Values(String... xs) {}\n", "record Values(String[]... xs) {}\n", "record Values(int... xs) {}\n", "record Values(@Deprecated String... xs) {}\n", "record Values(String... xs) { public String[] xs() { return xs; } }\n"}; static const char *return_types[] = {"String[]", "String[][]", "int[]", "String[]", "String[]"}; for (int fixture = 0; fixture < 5; fixture++) { CBMFileResult *result = cbm_extract_file(sources[fixture], (int)strlen(sources[fixture]), CBM_LANG_JAVA, "repro", "Values.java", 0, NULL, NULL); ASSERT_NOT_NULL(result); int accessors = 0; bool array_return = false; for (int i = 0; i < result->defs.count; i++) { CBMDefinition *def = &result->defs.items[i]; if (strcmp(def->name, "xs") == 0 && strcmp(def->label, "Method") == 0) { accessors++; array_return = def->return_type && strcmp(def->return_type, return_types[fixture]) == 0; } } cbm_free_result(result); ASSERT_EQ(accessors, 1); ASSERT_TRUE(array_return); } PASS(); } /* Comment extras in an otherwise empty parameter list must not create a * second, implicit accessor at the record component's source location. */ TEST(call_java_record_commented_accessor_has_only_explicit_span) { static const char *sources[] = {"record Value(int x) {\n" " public int x(/* explanation */) {\n" " return x;\n" " }\n" "}\n", "record Value(int x) {\n" " public int x(// explanation\n" " ) {\n" " return x;\n" " }\n" "}\n"}; static const int end_lines[] = {4, 5}; for (int fixture = 0; fixture < 2; fixture++) { CBMFileResult *result = cbm_extract_file(sources[fixture], (int)strlen(sources[fixture]), CBM_LANG_JAVA, "repro", "Value.java", 0, NULL, NULL); ASSERT_NOT_NULL(result); int accessors = 0; int explicit_spans = 0; for (int i = 0; i < result->defs.count; i++) { CBMDefinition *def = &result->defs.items[i]; if (strcmp(def->name, "x") == 0 && strcmp(def->label, "Method") == 0) { accessors++; if (def->start_line == 2 && def->end_line == end_lines[fixture]) { explicit_spans++; } } } cbm_free_result(result); ASSERT_EQ(accessors, 1); ASSERT_EQ(explicit_spans, 1); } PASS(); } TEST(call_java_record_commented_overload_keeps_implicit_accessor) { static const char source[] = "record Value(int x) {\n" " public int x(/* explanation */ int scale) { return x * scale; }\n" "}\n"; CBMFileResult *result = cbm_extract_file(source, (int)strlen(source), CBM_LANG_JAVA, "repro", "Value.java", 0, NULL, NULL); ASSERT_NOT_NULL(result); int methods = 0; int implicit_spans = 0; int overload_spans = 0; for (int i = 0; i < result->defs.count; i++) { CBMDefinition *def = &result->defs.items[i]; if (strcmp(def->name, "x") == 0 && strcmp(def->label, "Method") == 0) { methods++; if (def->start_line == 1 && def->end_line == 1) { implicit_spans++; } if (def->start_line == 2 && def->end_line == 2) { overload_spans++; } } } cbm_free_result(result); ASSERT_EQ(methods, 2); ASSERT_EQ(implicit_spans, 1); ASSERT_EQ(overload_spans, 1); PASS(); } SUITE(call_reference_contract) { RUN_TEST(call_reference_typescript_direct_argument_is_exact); RUN_TEST(call_reference_kotlin_alias_argument_is_exact); RUN_TEST(call_reference_python_use_before_local_shadow_is_not_global); RUN_TEST(call_reference_javascript_use_before_local_shadow_is_not_global); RUN_TEST(call_reference_typescript_use_before_local_shadow_is_not_global); RUN_TEST(call_reference_python_keyword_argument_is_exact); RUN_TEST(call_reference_python_bound_method_argument_is_exact); RUN_TEST(call_reference_python_parenthesized_bound_method_is_exact); RUN_TEST(call_reference_python_instance_field_shadow_is_not_method); RUN_TEST(call_reference_python_property_value_stays_usage); RUN_TEST(call_reference_python_unknown_decorated_value_stays_usage); RUN_TEST(call_reference_python_later_decorated_function_rebinding_stays_usage); RUN_TEST(call_reference_python_later_decorated_method_rebinding_stays_usage); RUN_TEST(call_reference_go_bound_method_argument_is_exact); RUN_TEST(call_reference_go_ambiguous_promoted_method_stays_usage); RUN_TEST(call_java_record_accessor_binds_the_record); RUN_TEST(call_java_record_varargs_accessor_has_array_return); RUN_TEST(call_java_record_commented_accessor_has_only_explicit_span); RUN_TEST(call_java_record_commented_overload_keeps_implicit_accessor); RUN_TEST(call_java_static_import_does_not_call_field_sequential); RUN_TEST(call_java_static_import_does_not_call_field_parallel); }