refactor(vm): use deref package and add unit tests for fetchFromEmbeddedInterfaces

Replace hand-rolled pointer/interface unwrap loops with deref.Value and
deref.Type, consistent with how Fetch already dereferences values.

Add white-box unit tests covering each branch (100% coverage of the
function): plain struct, embedded interface with/without field, pointer
to struct concrete value, nil concrete value, nil embedded pointer,
nested embedded struct, nested embedded interface, non-struct concrete
value, expr:"-" tag, and empty concrete struct.

Author: snaffi

vm/runtime/runtime.go

@@ -164,48 +164,21 @@ func fetchFromEmbeddedInterfaces(v reflect.Value, fieldName string) (any, bool)
 		if !f.Anonymous {
 			continue
 		}
-		fv := v.Field(i)
-		fk := f.Type.Kind()
-
-		// Dereference pointers to get to the underlying type.
-		for fk == reflect.Ptr {
-			if fv.IsNil() {
-				break
-			}
-			fv = fv.Elem()
-			fk = fv.Kind()
+		fv := deref.Value(v.Field(i))
+		if fv.Kind() != reflect.Struct {
+			continue
 		}
-
-		switch fk {
-		case reflect.Interface:
-			if fv.IsNil() {
-				continue
-			}
-			// Unwrap interface and dereference pointers to reach the
-			// concrete struct value.
-			concrete := fv.Elem()
-			for concrete.Kind() == reflect.Ptr {
-				if concrete.IsNil() {
-					break
-				}
-				concrete = concrete.Elem()
-			}
-			if concrete.Kind() != reflect.Struct {
-				continue
-			}
-			if value, _, ok := findStructField(concrete, fieldName); ok {
+		// Embedded interfaces need an explicit field lookup on the concrete
+		// value. Embedded structs are already covered by Go's standard field
+		// promotion, so we only recurse into them to find further embedded
+		// interfaces.
+		if deref.Type(f.Type).Kind() == reflect.Interface {
+			if value, _, ok := findStructField(fv, fieldName); ok {
 				return value.Interface(), true
 			}
-			// The concrete type itself may have embedded interfaces.
-			if result, found := fetchFromEmbeddedInterfaces(concrete, fieldName); found {
-				return result, found
-			}
-
-		case reflect.Struct:
-			// Recurse into embedded structs to find embedded interfaces.
-			if result, found := fetchFromEmbeddedInterfaces(fv, fieldName); found {
-				return result, found
-			}
+		}
+		if result, found := fetchFromEmbeddedInterfaces(fv, fieldName); found {
+			return result, true
 		}
 	}
 	return nil, false

vm/runtime/runtime_internal_test.go

@@ -0,0 +1,173 @@
+package runtime
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+type Namer interface {
+	Name() string
+}
+
+type IntHolder interface {
+	Int() int
+}
+
+type ConcreteWithName struct {
+	Title string
+}
+
+func (ConcreteWithName) Name() string { return "" }
+
+type ConcreteWithSkippedField struct {
+	Title string `expr:"-"`
+}
+
+func (ConcreteWithSkippedField) Name() string { return "" }
+
+type ConcreteEmptyStruct struct{}
+
+func (ConcreteEmptyStruct) Name() string { return "" }
+
+type ConcreteInt int
+
+func (ConcreteInt) Int() int { return 0 }
+
+type ConcreteWithEmbeddedInterface struct {
+	Namer
+}
+
+func (ConcreteWithEmbeddedInterface) Int() int { return 0 }
+
+type EmbeddedInterfaceOnly struct {
+	Namer
+}
+
+type EmbeddedNilPointerOnly struct {
+	*ConcreteWithName
+}
+
+type EmbeddedStructWithInterface struct {
+	EmbeddedInterfaceOnly
+}
+
+type EmbeddedIntHolder struct {
+	IntHolder
+}
+
+type PlainStruct struct {
+	Title string
+}
+
+func TestFetchFromEmbeddedInterfaces(t *testing.T) {
+	tests := []struct {
+		name      string
+		input     any
+		fieldName string
+		want      any
+		ok        bool
+	}{
+		{
+			name:      "no anonymous fields",
+			input:     PlainStruct{Title: "ignored"},
+			fieldName: "Title",
+			ok:        false,
+		},
+		{
+			name: "embedded interface with field on concrete struct",
+			input: EmbeddedInterfaceOnly{
+				Namer: ConcreteWithName{Title: "hello"},
+			},
+			fieldName: "Title",
+			want:      "hello",
+			ok:        true,
+		},
+		{
+			name: "embedded interface, concrete missing field",
+			input: EmbeddedInterfaceOnly{
+				Namer: ConcreteWithName{Title: "hello"},
+			},
+			fieldName: "Missing",
+			ok:        false,
+		},
+		{
+			name: "embedded interface holding pointer to struct",
+			input: EmbeddedInterfaceOnly{
+				Namer: &ConcreteWithName{Title: "pointer"},
+			},
+			fieldName: "Title",
+			want:      "pointer",
+			ok:        true,
+		},
+		{
+			name:      "embedded interface with nil concrete value",
+			input:     EmbeddedInterfaceOnly{Namer: nil},
+			fieldName: "Title",
+			ok:        false,
+		},
+		{
+			name:      "embedded nil pointer to struct",
+			input:     EmbeddedNilPointerOnly{ConcreteWithName: nil},
+			fieldName: "Title",
+			ok:        false,
+		},
+		{
+			name: "embedded struct containing embedded interface with field",
+			input: EmbeddedStructWithInterface{
+				EmbeddedInterfaceOnly: EmbeddedInterfaceOnly{
+					Namer: ConcreteWithName{Title: "nested"},
+				},
+			},
+			fieldName: "Title",
+			want:      "nested",
+			ok:        true,
+		},
+		{
+			name: "embedded interface whose concrete embeds another interface",
+			input: EmbeddedIntHolder{
+				IntHolder: ConcreteWithEmbeddedInterface{
+					Namer: ConcreteWithName{Title: "deep"},
+				},
+			},
+			fieldName: "Title",
+			want:      "deep",
+			ok:        true,
+		},
+		{
+			name: "embedded interface with non-struct concrete value",
+			input: EmbeddedIntHolder{
+				IntHolder: ConcreteInt(5),
+			},
+			fieldName: "Title",
+			ok:        false,
+		},
+		{
+			name: "field is skipped via expr:\"-\" tag",
+			input: EmbeddedInterfaceOnly{
+				Namer: ConcreteWithSkippedField{Title: "hidden"},
+			},
+			fieldName: "Title",
+			ok:        false,
+		},
+		{
+			name: "embedded interface with empty concrete struct, recurses to nothing",
+			input: EmbeddedInterfaceOnly{
+				Namer: ConcreteEmptyStruct{},
+			},
+			fieldName: "Title",
+			ok:        false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := fetchFromEmbeddedInterfaces(reflect.ValueOf(tt.input), tt.fieldName)
+			require.Equal(t, tt.ok, ok)
+			if tt.ok {
+				require.Equal(t, tt.want, got)
+			}
+		})
+	}
+}