support const "enum" values with stringer.String values?

[rcoreilly]

I would like to be able to eval an expr like this: EnumVal == Enum1 where I've defined ConstVal to be a standard Go const enum type:

//go:generate stringer -type=MyEnums

type MyEnums int

const (
    Enum1 MyEnums = iota
    Enum2 
)

type MyStruct struct {
    EnumVal MyEnums
}

var stru MyStruct

ev := expr.Eval(`EnumVal==Enum1`, stru)

so the string values are available and could be tested against.

Any chance of adding this?

[antonmedv]

The variable EnumVal is available in Expr. But list of constants not. And it’s not possible to get such list by reflection. Only by ast parsing.

One possible solution is to add list of enum values as another variable/variables.

[rcoreilly]

I could do a quick PR if you'd accept it?

[antonmedv]

I think this is very optional. Others may use stringer with different purposes.

You use case can be achieved by using the patcher.

[rcoreilly]

yeah as I looked into it, it isn't very clean to detect the undefined identifier node because you don't mark it explicitly, and if this hasn't come up in other users cases, then probably just another workaround is better. probably operator overloading with the stringer case like in your tests would be easier?

[rcoreilly]

It doesn't look possible to register just regular standalone functions as operators? they need to be methods on the one struct type being processed? In my case, I have a struct type that could be anything, and won't have the relevant operator to overload with -- I would like to be able to specify my own function to do the overloaded == operation. Is that possible?

[rcoreilly]

also your docs need to be updated with the new CallNode instead of MethodNode for patcher.

[rcoreilly]

Here's a working patcher solution for anyone else's reference:

type viewifPatcher struct{}

var stringer = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()

func (p *viewifPatcher) Visit(node *ast.Node) {
	switch x := (*node).(type) {
	case *ast.BinaryNode:
		if lid, ok := x.Left.(*ast.IdentifierNode); ok && x.Operator == "==" {
			if rid, ok := x.Right.(*ast.IdentifierNode); ok {
				lt := lid.Type()
				if lt == nil {
					return
				}
				if lt.Implements(stringer) {
					ast.Patch(node, &ast.BinaryNode{
						Operator: "==",
						Left: &ast.CallNode{
							Callee: &ast.MemberNode{
								Node:     x.Left,
								Property: &ast.StringNode{Value: "String"},
							},
						},
						Right: &ast.StringNode{
							Value: rid.Value,
						},
					})
				}
			}
		}
	}
}