Enhancement Request: support extracting expected program inputs

[scosman]

I'm building a system where there is a non trivial cost to building the environment and the program isn't known in advance. There are a few hundred possible inputs, but most programs will only need one or two. I'd like to only populate the environment with the necessary inputs, saving a lot of compute cost getting the rest.

Is there any good way (or can one be added) to get the expected inputs? Ideally a map of name:type so I can validate the types match.

I've hacked one together below, but I'm not certain it covers all cases (OpLoadField/OpFetchField might be missing?), and it doesn't give me the expected type. If this isn't an ER you'd want to take to main, can you comment on if I'm missing anything important in this version?

Thanks in advance!

	code := "(a > 5555) && b && 'asdf' == c && 2 in [d, 3, 4]"
	emptyEnv := expr.Env(map[string]interface{}{})
	program, err := expr.Compile(code, emptyEnv, expr.AllowUndefinedVariables(), expr.AsBool())

	variableMap := map[string]bool{}
	for i, bytecode := range program.Bytecode {
		if bytecode == vm.OpLoadFast {
			arg := program.Arguments[i]
			varName, ok := program.Constants[arg].(string)
			if ok {
				variableMap[varName] = true
			}
		}
	}
	variables := maps.Keys(variableMap)
        fmt.Printf("Program variables: %v\n", variables)
        // Program variables: [a b c d]

[scosman]

Ahhhh, you have a sample for this in docs. https://expr.medv.io/docs/Visitor-and-Patch

Will leave this open as an feature request, but understand if you close it.

[mdmcconnell]

Ha! Just what I was thinking - one way to attack this might be use a Visitor to check all the nodes in the tree, and load every identifier you come across from your set of hundreds. But getting the expected type might be a little tricky.

[scosman]

One more note: it would be nice to have an official api because a few tricks to figure out (like calling optimize). But it's doable without one.

[scosman]

Here's what I ended up with. Had to dive into internals a bit to get this working with config/methods/optimizer, might be handy as a tested part of the main project, but I leave that up to you!

type cmAnalysisVisitor struct {
	variables []string
}

func (v *cmAnalysisVisitor) Visit(n *ast.Node) {
	if node, ok := (*n).(*ast.IdentifierNode); ok {
		if !node.Method {
			v.variables = append(v.variables, node.Value)
		}
	}
}

func extractVariablesFromCode(code string) ([]string, error) {
	tree, err := parser.Parse(code)
	if err != nil {
		return nil, err
	}

	config := conf.New(cmExprEnv{})
	config.Strict = false
	_, err = checker.Check(tree, config)
	if err != nil {
		return nil, err
	}
	err = optimizer.Optimize(&tree.Node, config)
	if err != nil {
		return nil, err
	}

	visitor := &cmAnalysisVisitor{}
	ast.Walk(&tree.Node, visitor)
	return visitor.variables, nil
}