2c700230de
* proc: use stack machine to evaluate expressions This commit splits expression evaluation into two parts. The first part (in pkg/proc/evalop/evalcompile.go) "compiles" as ast.Expr into a list of instructions (defined in pkg/proc/evalop/ops.go) for a stack machine (defined by `proc.(*evalStack)`). The second part is a stack machine (implemented by `proc.(*EvalScope).eval` and `proc.(*EvalScope).evalOne`) that has two modes of operation: in the main mode it executes inteructions from the list (by calling `evalOne`), in the second mode it executes the call injection protocol by calling `funcCallStep` repeatedly until it either the protocol finishes, needs more input from the stack machine (to set call arguments) or fails. This approach has several benefits: - it is now possible to remove the goroutine we use to evaluate expression and the channel used to communicate with the Continue loop. - every time we resume the target to execute the call injection protocol we need to update several local variables to match the changed state of the target, this is now done at the top level of the evaluation loop instead of being hidden inside a recurisive evaluator - using runtime.Pin to pin addresses returned by an injected call would allow us to use a more natural evaluation order for function calls, which would solve some bugs #3310, allow users to inspect values returned by a call injection #1599 and allow implementing some other features #1465. Doing this with the recursive evaluator, while keeping backwards compatibility with versions of Go that do not have runtime.Pin is very hard. However after this change we can simply conditionally change how compileFunctionCall works and add some opcodes. * review round 1 * review round 2
76 lines
1.6 KiB
Go
76 lines
1.6 KiB
Go
package evalop
|
|
|
|
import (
|
|
"go/ast"
|
|
"go/parser"
|
|
"go/token"
|
|
"testing"
|
|
)
|
|
|
|
func assertNoError(err error, t testing.TB, s string) {
|
|
t.Helper()
|
|
if err != nil {
|
|
t.Fatalf("failed assertion %s: %s\n", s, err)
|
|
}
|
|
}
|
|
|
|
func TestEvalSwitchExhaustiveness(t *testing.T) {
|
|
// Checks that the switch statement in (*EvalScope).evalOne of
|
|
// pkg/proc/eval.go exhaustively covers all implementations of the
|
|
// evalop.Op interface.
|
|
|
|
ops := make(map[string]bool)
|
|
|
|
var fset, fset2 token.FileSet
|
|
f, err := parser.ParseFile(&fset, "ops.go", nil, 0)
|
|
assertNoError(err, t, "ParseFile")
|
|
for _, decl := range f.Decls {
|
|
decl, _ := decl.(*ast.FuncDecl)
|
|
if decl == nil {
|
|
continue
|
|
}
|
|
if decl.Name.Name != "depthCheck" {
|
|
continue
|
|
}
|
|
ops[decl.Recv.List[0].Type.(*ast.StarExpr).X.(*ast.Ident).Name] = false
|
|
}
|
|
|
|
f, err = parser.ParseFile(&fset2, "../eval.go", nil, 0)
|
|
assertNoError(err, t, "ParseFile")
|
|
for _, decl := range f.Decls {
|
|
decl, _ := decl.(*ast.FuncDecl)
|
|
if decl == nil {
|
|
continue
|
|
}
|
|
if decl.Name.Name != "executeOp" {
|
|
continue
|
|
}
|
|
ast.Inspect(decl, func(n ast.Node) bool {
|
|
sw, _ := n.(*ast.TypeSwitchStmt)
|
|
if sw == nil {
|
|
return true
|
|
}
|
|
|
|
for _, c := range sw.Body.List {
|
|
if len(c.(*ast.CaseClause).List) == 0 {
|
|
// default clause
|
|
continue
|
|
}
|
|
sel := c.(*ast.CaseClause).List[0].(*ast.StarExpr).X.(*ast.SelectorExpr)
|
|
if sel.X.(*ast.Ident).Name != "evalop" {
|
|
t.Fatalf("wrong case statement at: %v", fset2.Position(sel.Pos()))
|
|
}
|
|
|
|
ops[sel.Sel.Name] = true
|
|
}
|
|
return false
|
|
})
|
|
}
|
|
|
|
for op := range ops {
|
|
if !ops[op] {
|
|
t.Errorf("evalop.Op %s not used in evalOne", op)
|
|
}
|
|
}
|
|
}
|