Merge branch 'master' into fix/issue-825

Author: antonmedv

checker/checker.go

@@ -462,7 +462,7 @@ func (v *Checker) binaryNode(node *ast.BinaryNode) Nature {
 				return v.error(node, err.Error())
 			}
 		}
-		if l.IsString() && r.IsString() {
+		if (l.IsString() || l.IsByteSlice()) && r.IsString() {
 			return v.config.NtCache.FromType(boolType)
 		}
 		if l.MaybeCompatible(&v.config.NtCache, r, StringCheck) {
@@ -549,6 +549,13 @@ func (v *Checker) memberNode(node *ast.MemberNode) Nature {
 
 	switch base.Kind {
 	case reflect.Map:
+		// If the map key is a pointer, we should not dereference the property.
+		if !prop.AssignableTo(base.Key(&v.config.NtCache)) {
+			propDeref := prop.Deref(&v.config.NtCache)
+			if propDeref.AssignableTo(base.Key(&v.config.NtCache)) {
+				prop = propDeref
+			}
+		}
 		if !prop.AssignableTo(base.Key(&v.config.NtCache)) && !prop.IsUnknown(&v.config.NtCache) {
 			return v.error(node.Property, "cannot use %s to get an element from %s", prop.String(), base.String())
 		}
@@ -562,6 +569,7 @@ func (v *Checker) memberNode(node *ast.MemberNode) Nature {
 		return base.Elem(&v.config.NtCache)
 
 	case reflect.Array, reflect.Slice:
+		prop = prop.Deref(&v.config.NtCache)
 		if !prop.IsInteger && !prop.IsUnknown(&v.config.NtCache) {
 			return v.error(node.Property, "array elements can only be selected using an integer (got %s)", prop.String())
 		}
@@ -607,13 +615,15 @@ func (v *Checker) sliceNode(node *ast.SliceNode) Nature {
 
 	if node.From != nil {
 		from := v.visit(node.From)
+		from = from.Deref(&v.config.NtCache)
 		if !from.IsInteger && !from.IsUnknown(&v.config.NtCache) {
 			return v.error(node.From, "non-integer slice index %v", from.String())
 		}
 	}
 
 	if node.To != nil {
 		to := v.visit(node.To)
+		to = to.Deref(&v.config.NtCache)
 		if !to.IsInteger && !to.IsUnknown(&v.config.NtCache) {
 			return v.error(node.To, "non-integer slice index %v", to.String())
 		}
@@ -942,6 +952,7 @@ func (v *Checker) checkBuiltinGet(node *ast.BuiltinNode) Nature {
 
 	base := v.visit(node.Arguments[0])
 	prop := v.visit(node.Arguments[1])
+	prop = prop.Deref(&v.config.NtCache)
 
 	if id, ok := node.Arguments[0].(*ast.IdentifierNode); ok && id.Value == "$env" {
 		if s, ok := node.Arguments[1].(*ast.StringNode); ok {
@@ -1260,6 +1271,7 @@ func (v *Checker) sequenceNode(node *ast.SequenceNode) Nature {
 
 func (v *Checker) conditionalNode(node *ast.ConditionalNode) Nature {
 	c := v.visit(node.Cond)
+	c = c.Deref(&v.config.NtCache)
 	if !c.IsBool() && !c.IsUnknown(&v.config.NtCache) {
 		return v.error(node.Cond, "non-bool expression (type %v) used as condition", c.String())
 	}

checker/nature/nature.go

@@ -10,11 +10,12 @@ import (
 )
 
 var (
-	intType      = reflect.TypeOf(0)
-	floatType    = reflect.TypeOf(float64(0))
-	arrayType    = reflect.TypeOf([]any{})
-	timeType     = reflect.TypeOf(time.Time{})
-	durationType = reflect.TypeOf(time.Duration(0))
+	intType       = reflect.TypeOf(0)
+	floatType     = reflect.TypeOf(float64(0))
+	arrayType     = reflect.TypeOf([]any{})
+	byteSliceType = reflect.TypeOf([]byte{})
+	timeType      = reflect.TypeOf(time.Time{})
+	durationType  = reflect.TypeOf(time.Duration(0))
 
 	builtinInt = map[reflect.Type]struct{}{
 		reflect.TypeOf(int(0)):     {},
@@ -502,6 +503,10 @@ func (n *Nature) IsString() bool {
 	return n.Kind == reflect.String
 }
 
+func (n *Nature) IsByteSlice() bool {
+	return n.Type == byteSliceType
+}
+
 func (n *Nature) IsArray() bool {
 	return n.Kind == reflect.Slice || n.Kind == reflect.Array
 }

compiler/compiler.go

@@ -716,6 +716,18 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 
 	if op == OpFetch {
 		c.compile(node.Property)
+		deref := true
+		// If the map key is a pointer, we should not dereference the property.
+		if node.Node.Type() != nil && node.Node.Type().Kind() == reflect.Map {
+			keyType := node.Node.Type().Key()
+			propType := node.Property.Type()
+			if propType != nil && propType.AssignableTo(keyType) {
+				deref = false
+			}
+		}
+		if deref {
+			c.derefInNeeded(node.Property)
+		}
 		c.emit(OpFetch)
 	} else {
 		c.emitLocation(node.Location(), op, c.addConstant(
@@ -728,11 +740,13 @@ func (c *compiler) SliceNode(node *ast.SliceNode) {
 	c.compile(node.Node)
 	if node.To != nil {
 		c.compile(node.To)
+		c.derefInNeeded(node.To)
 	} else {
 		c.emit(OpLen)
 	}
 	if node.From != nil {
 		c.compile(node.From)
+		c.derefInNeeded(node.From)
 	} else {
 		c.emitPush(0)
 	}
@@ -1213,6 +1227,7 @@ func (c *compiler) lookupVariable(name string) (int, bool) {
 
 func (c *compiler) ConditionalNode(node *ast.ConditionalNode) {
 	c.compile(node.Cond)
+	c.derefInNeeded(node.Cond)
 	otherwise := c.emit(OpJumpIfFalse, placeholder)
 
 	c.emit(OpPop)

test/issues/836/issue_test.go

@@ -0,0 +1,101 @@
+package issue_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+type InputStruct struct {
+	Enabled *bool `json:"enabled"`
+}
+
+func TestIssue836(t *testing.T) {
+	str := "foo"
+	ptrStr := &str
+	b := true
+	ptrBool := &b
+	i := 1
+	ptrInt := &i
+
+	env := map[string]interface{}{
+		"ptrStr":  ptrStr,
+		"ptrBool": ptrBool,
+		"ptrInt":  ptrInt,
+		"arr":     []int{1, 2, 3},
+		"mapPtr":  map[*int]int{ptrInt: 42},
+	}
+
+	t.Run("map access with pointer key", func(t *testing.T) {
+		program, err := expr.Compile(`{"foo": "bar"}[ptrStr]`, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, "bar", output)
+	})
+
+	t.Run("conditional with pointer condition", func(t *testing.T) {
+		program, err := expr.Compile(`ptrBool ? 1 : 0`, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, 1, output)
+	})
+
+	t.Run("get() with pointer key", func(t *testing.T) {
+		program, err := expr.Compile(`get({"foo": "bar"}, ptrStr)`, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, "bar", output)
+	})
+
+	t.Run("struct field pointer check in ternary", func(t *testing.T) {
+		var v InputStruct
+		// v.Enabled is nil
+
+		env := map[string]any{
+			"v": v,
+		}
+
+		code := `v.Enabled == nil ? 'default' : ( v.Enabled ? 'enabled' : 'disabled' )`
+
+		program, err := expr.Compile(code, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, "default", output)
+	})
+
+	t.Run("struct field pointer check in ternary (enabled)", func(t *testing.T) {
+		b := true
+		v := InputStruct{Enabled: &b}
+
+		env := map[string]any{
+			"v": v,
+		}
+
+		code := `v.Enabled == nil ? 'default' : ( v.Enabled ? 'enabled' : 'disabled' )`
+
+		program, err := expr.Compile(code, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, "enabled", output)
+	})
+
+	t.Run("slice with pointer indices", func(t *testing.T) {
+		program, err := expr.Compile(`arr[ptrInt:ptrInt]`, expr.Env(env))
+		require.NoError(t, err)
+
+		output, err := expr.Run(program, env)
+		require.NoError(t, err)
+		require.Equal(t, []int{}, output)
+	})
+}

test/issues/854/issue_test.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+	"github.com/expr-lang/expr/types"
+)
+
+func TestIssue854(t *testing.T) {
+	envType := types.Map{
+		"user": types.Map{
+			// If we do not specify `Profile` here,
+			// this is a correct behavior to throw
+			// on a missing property.
+		},
+	}
+
+	code := `user.Profile?.Address ?? "Unknown address"`
+
+	_, err := expr.Compile(code, expr.Env(envType))
+	require.Error(t, err)
+}

vm/vm.go

@@ -303,7 +303,13 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 				vm.push(false)
 				break
 			}
-			match, err := regexp.MatchString(b.(string), a.(string))
+			var match bool
+			var err error
+			if s, ok := a.(string); ok {
+				match, err = regexp.MatchString(b.(string), s)
+			} else {
+				match, err = regexp.Match(b.(string), a.([]byte))
+			}
 			if err != nil {
 				panic(err)
 			}
@@ -316,7 +322,11 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) {
 				break
 			}
 			r := program.Constants[arg].(*regexp.Regexp)
-			vm.push(r.MatchString(a.(string)))
+			if s, ok := a.(string); ok {
+				vm.push(r.MatchString(s))
+			} else {
+				vm.push(r.Match(a.([]byte)))
+			}
 
 		case OpContains:
 			b := vm.pop()

vm/vm_test.go

@@ -368,6 +368,18 @@ func TestVM_OpcodeOperations(t *testing.T) {
 			expr: `"hello123" matches "^hello\\d+$"`,
 			want: true,
 		},
+		{
+			name: "byte slice matches regex",
+			expr: `b matches "^hello\\d+$"`,
+			env:  map[string]any{"b": []byte("hello123")},
+			want: true,
+		},
+		{
+			name: "byte slice matches dynamic regex",
+			expr: `b matches pattern`,
+			env:  map[string]any{"b": []byte("hello123"), "pattern": "^hello\\d+$"},
+			want: true,
+		},
 
 		// Data Structure Operations
 		{