chore: import upstream snapshot with attribution

internal/resolver/fn_pointer_dispatch_test.go

@@ -0,0 +1,88 @@
+package resolver
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/zzet/gortex/internal/graph"
+)
+
+func fnDef(g *graph.Graph, id, file, name string) {
+	g.AddNode(&graph.Node{ID: id, Kind: graph.KindFunction, Name: name, FilePath: file, Language: "c"})
+}
+
+func fnPtrReg(g *graph.Graph, file, st, field, fn string) {
+	g.AddEdge(&graph.Edge{From: file, To: "unresolved::*." + fn, Kind: graph.EdgeReferences, FilePath: file,
+		Meta: map[string]any{"via": fnPtrRegVia, "fnptr_struct": st, "fnptr_field": field, "fnptr_fn": fn}})
+}
+
+func fnPtrCopy(g *graph.Graph, file, toSt, toField, fromSt, fromField string) {
+	g.AddEdge(&graph.Edge{From: file, To: "unresolved::*." + fromField, Kind: graph.EdgeReferences, FilePath: file,
+		Meta: map[string]any{"via": fnPtrRegVia, "fnptr_struct": toSt, "fnptr_field": toField, "fnptr_copy_struct": fromSt, "fnptr_copy_field": fromField}})
+}
+
+func fnPtrDispatch(g *graph.Graph, fromID, file, st, field string) {
+	if g.GetNode(fromID) == nil {
+		g.AddNode(&graph.Node{ID: fromID, Kind: graph.KindFunction, Name: lastSeg(fromID), FilePath: file, Language: "c"})
+	}
+	g.AddEdge(&graph.Edge{From: fromID, To: "unresolved::*." + field, Kind: graph.EdgeCalls, FilePath: file,
+		Meta: map[string]any{"via": fnPtrDispatchVia, "fnptr_struct": st, "fnptr_field": field}})
+}
+
+func synthFnPtrEdge(g graph.Store, from, to string) *graph.Edge {
+	for e := range g.EdgesByKind(graph.EdgeCalls) {
+		if e == nil || e.From != from || e.To != to || e.Meta == nil {
+			continue
+		}
+		if by, _ := e.Meta[MetaSynthesizedBy].(string); by == SynthFnPointerDispatch {
+			return e
+		}
+	}
+	return nil
+}
+
+func TestResolveFnPointerDispatch_CommandTableFanOut(t *testing.T) {
+	g := graph.New()
+	fnDef(g, "cmds.c::cmd_add", "cmds.c", "cmd_add")
+	fnDef(g, "cmds.c::cmd_rm", "cmds.c", "cmd_rm")
+	fnDef(g, "cmds.c::run", "cmds.c", "run")
+	fnPtrReg(g, "cmds.c", "cmd", "fn", "cmd_add")
+	fnPtrReg(g, "cmds.c", "cmd", "fn", "cmd_rm")
+	fnPtrDispatch(g, "cmds.c::run", "cmds.c", "cmd", "fn")
+
+	n := ResolveFnPointerDispatch(g)
+	require.Equal(t, 2, n, "the dispatch fans out to both registered commands")
+	a := synthFnPtrEdge(g, "cmds.c::run", "cmds.c::cmd_add")
+	require.NotNil(t, a)
+	assert.Equal(t, fnPointerConfidence, a.Confidence)
+	assert.Equal(t, ProvenanceHeuristic, a.Meta[MetaProvenance])
+	assert.NotNil(t, synthFnPtrEdge(g, "cmds.c::run", "cmds.c::cmd_rm"))
+}
+
+func TestResolveFnPointerDispatch_FieldCopyFixpoint(t *testing.T) {
+	// op_x is registered to (B, h); A.h is copied from B.h; a dispatch on A
+	// must reach op_x through the fixpoint.
+	g := graph.New()
+	fnDef(g, "ops.c::op_x", "ops.c", "op_x")
+	fnDef(g, "ops.c::run_a", "ops.c", "run_a")
+	fnPtrReg(g, "ops.c", "B", "h", "op_x")
+	fnPtrCopy(g, "ops.c", "A", "h", "B", "h")
+	fnPtrDispatch(g, "ops.c::run_a", "ops.c", "A", "h")
+
+	n := ResolveFnPointerDispatch(g)
+	require.Equal(t, 1, n)
+	assert.NotNil(t, synthFnPtrEdge(g, "ops.c::run_a", "ops.c::op_x"),
+		"the field-copy fixpoint propagates B.h's function to A.h")
+}
+
+func TestResolveFnPointerDispatch_UnregisteredSlotStaysPlaceholder(t *testing.T) {
+	g := graph.New()
+	fnDef(g, "x.c::handler", "x.c", "handler")
+	fnPtrReg(g, "x.c", "S", "f", "handler")
+	// dispatch on a different slot with no registrations.
+	fnPtrDispatch(g, "x.c::run", "x.c", "S", "other")
+
+	assert.Equal(t, 0, ResolveFnPointerDispatch(g))
+}