feat: add "expr_noreflectmethod" build tag

By enabling this tag, two features are removed:
- functions in environment
- Eval() method

Fix #863.

Author: vincentbernat

builtin/lib.go

@@ -562,9 +562,8 @@ func get(params ...any) (out any, err error) {
 	// Methods can be defined on any type.
 	if v.NumMethod() > 0 {
 		if methodName, ok := i.(string); ok {
-			method := v.MethodByName(methodName)
-			if method.IsValid() {
-				return method.Interface(), nil
+			if m, ok := runtime.MethodByName(v, methodName); ok {
+				return m, nil
 			}
 		}
 	}

checker/info.go

@@ -37,10 +37,10 @@ func MethodIndex(c *Cache, env Nature, node ast.Node) (bool, int, string) {
 		}
 	case *ast.MemberNode:
 		if name, ok := n.Property.(*ast.StringNode); ok {
-			base := n.Node.Type()
-			if base != nil && base.Kind() != reflect.Interface {
-				if m, ok := base.MethodByName(name.Value); ok {
-					return true, m.Index, name.Value
+			base := n.Node.Nature()
+			if base != nil && base.Kind != reflect.Interface {
+				if m, ok := base.MethodByName(c, name.Value); ok {
+					return true, m.MethodIndex, name.Value
 				}
 			}
 		}

checker/nature/nature.go

@@ -294,15 +294,6 @@ func (n *Nature) NumMethods(c *Cache) int {
 	return 0
 }
 
-func (n *Nature) MethodByName(c *Cache, name string) (Nature, bool) {
-	if s := n.getMethodset(c); s != nil {
-		if m := s.method(c, name); m != nil {
-			return m.nature, true
-		}
-	}
-	return Nature{}, false
-}
-
 func (n *Nature) NumIn() int {
 	if n.numInSet {
 		return n.numIn

checker/nature/no_reflectmethod.go

@@ -0,0 +1,11 @@
+//go:build expr_noreflectmethod
+
+package nature
+
+// MethodByName is a no-op stub used when building with the
+// expr_noreflectmethod tag. It avoids reaching reflect.Type.Method via the
+// methodset cache so the Go linker can perform full method dead-code
+// elimination on user types.
+func (n *Nature) MethodByName(c *Cache, name string) (Nature, bool) {
+	return Nature{}, false
+}

checker/nature/reflectmethod.go

@@ -0,0 +1,14 @@
+//go:build !expr_noreflectmethod
+
+package nature
+
+// MethodByName looks up a method on a Nature by name. It transitively reaches
+// reflect.Type.Method via the methodset cache.
+func (n *Nature) MethodByName(c *Cache, name string) (Nature, bool) {
+	if s := n.getMethodset(c); s != nil {
+		if m := s.method(c, name); m != nil {
+			return m.nature, true
+		}
+	}
+	return Nature{}, false
+}

compiler/compiler.go

@@ -783,9 +783,12 @@ func (c *compiler) CallNode(node *ast.CallNode) {
 		switch callee := node.Callee.(type) {
 		case *ast.MemberNode:
 			if prop, ok := callee.Property.(*ast.StringNode); ok {
-				if _, ok = callee.Node.Type().MethodByName(prop.Value); ok && callee.Node.Type().Kind() != reflect.Interface {
-					fnInOffset = 1
-					fnNumIn--
+				base := callee.Node.Nature()
+				if base != nil && base.Kind != reflect.Interface {
+					if _, ok := base.MethodByName(c.ntCache, prop.Value); ok {
+						fnInOffset = 1
+						fnNumIn--
+					}
 				}
 			}
 		case *ast.IdentifierNode:

expr.go

@@ -13,7 +13,6 @@ import (
 	"github.com/expr-lang/expr/conf"
 	"github.com/expr-lang/expr/file"
 	"github.com/expr-lang/expr/optimizer"
-	"github.com/expr-lang/expr/parser"
 	"github.com/expr-lang/expr/patcher"
 	"github.com/expr-lang/expr/vm"
 )
@@ -25,7 +24,8 @@ type Option func(c *conf.Config)
 // If struct is passed, all fields will be treated as variables,
 // as well as all fields of embedded structs and struct itself.
 // If map is passed, all items will be treated as variables.
-// Methods defined on this type will be available as functions.
+// Methods defined on this type will be available as functions,
+// unless built with the expr_noreflectmethod build tag.
 func Env(env any) Option {
 	return func(c *conf.Config) {
 		c.WithEnv(env)
@@ -264,27 +264,3 @@ func Compile(input string, ops ...Option) (*vm.Program, error) {
 func Run(program *vm.Program, env any) (any, error) {
 	return vm.Run(program, env)
 }
-
-// Eval parses, compiles and runs given input.
-func Eval(input string, env any) (any, error) {
-	if _, ok := env.(Option); ok {
-		return nil, fmt.Errorf("misused expr.Eval: second argument (env) should be passed without expr.Env")
-	}
-
-	tree, err := parser.Parse(input)
-	if err != nil {
-		return nil, err
-	}
-
-	program, err := compiler.Compile(tree, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	output, err := Run(program, env)
-	if err != nil {
-		return nil, err
-	}
-
-	return output, nil
-}

expr_no_reflectmethod.go

@@ -0,0 +1,10 @@
+//go:build expr_noreflectmethod
+
+package expr
+
+// Eval is a panic-only stub used when building with the expr_noreflectmethod
+// tag. The real Eval relies on runtime dispatch on the env, which requires
+// reflect-based method resolution. Use Compile + Run instead.
+func Eval(input string, env any) (any, error) {
+	panic("expr.Eval is not available with the expr_noreflectmethod build tag")
+}

expr_reflectmethod.go

@@ -0,0 +1,38 @@
+//go:build !expr_noreflectmethod
+
+package expr
+
+import (
+	"fmt"
+
+	"github.com/expr-lang/expr/compiler"
+	"github.com/expr-lang/expr/parser"
+)
+
+// Eval parses, compiles and runs given input.
+//
+// Eval is excluded from the build under the expr_noreflectmethod tag because
+// it relies on runtime dispatch on the env, which requires reflect-based
+// method resolution.
+func Eval(input string, env any) (any, error) {
+	if _, ok := env.(Option); ok {
+		return nil, fmt.Errorf("misused expr.Eval: second argument (env) should be passed without expr.Env")
+	}
+
+	tree, err := parser.Parse(input)
+	if err != nil {
+		return nil, err
+	}
+
+	program, err := compiler.Compile(tree, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	output, err := Run(program, env)
+	if err != nil {
+		return nil, err
+	}
+
+	return output, nil
+}

vm/runtime/no_reflectmethod.go

@@ -0,0 +1,19 @@
+//go:build expr_noreflectmethod
+
+package runtime
+
+import "reflect"
+
+// MethodByName is a no-op stub used when building with the
+// expr_noreflectmethod tag. It avoids reaching reflect.Value.MethodByName so
+// the Go linker can perform full method dead-code elimination on user types.
+func MethodByName(v reflect.Value, name string) (any, bool) {
+	return nil, false
+}
+
+// MethodByIndex is a no-op stub used when building with the
+// expr_noreflectmethod tag. It avoids reaching reflect.Value.Method so the Go
+// linker can perform full method dead-code elimination on user types.
+func MethodByIndex(v reflect.Value, index int) (any, bool) {
+	return nil, false
+}