new gcs evaluator - attempt at fixing performance issue introduced via gcsl rework

cmd/wasm/main.go

@@ -11,8 +11,8 @@ import (
 
 	"github.com/genshinsim/gcsim/pkg/agg"
 	"github.com/genshinsim/gcsim/pkg/core/info"
-	"github.com/genshinsim/gcsim/pkg/gcs"
 	"github.com/genshinsim/gcsim/pkg/gcs/ast"
+	"github.com/genshinsim/gcsim/pkg/gcs/eval"
 	"github.com/genshinsim/gcsim/pkg/model"
 	"github.com/genshinsim/gcsim/pkg/simulation"
 	"github.com/genshinsim/gcsim/pkg/simulator"
@@ -133,7 +133,7 @@ func simulate(this js.Value, args []js.Value) (out interface{}) {
 	if err != nil {
 		return marshal(err)
 	}
-	eval, err := gcs.NewEvaluator(program, core)
+	eval, err := eval.NewEvaluator(program, core)
 	if err != nil {
 		return marshal(err)
 	}

pkg/gcs/ast/node.go

@@ -375,7 +375,9 @@ func (s *SwitchStmt) String() string {
 
 func (s *SwitchStmt) writeTo(sb *strings.Builder) {
 	sb.WriteString("switch ")
-	s.Condition.writeTo(sb)
+	if s.Condition != nil {
+		s.Condition.writeTo(sb)
+	}
 	sb.WriteString(" {\n")
 	for _, v := range s.Cases {
 		v.writeTo(sb)

pkg/gcs/ast/parseCharacterAction.go

@@ -9,7 +9,7 @@ import (
 
 // parseAction returns a node contain a character action, or a block of node containing
 // a list of character actions
-func (p *Parser) parseAction() (Stmt, error) {
+func (p *Parser) parseAction() (Node, error) {
 	char, err := p.consume(itemCharacterKey)
 	if err != nil {
 		// this really shouldn't happen since we already checked
@@ -88,6 +88,10 @@ Loop:
 	}
 	// check for optional flags
 
+	if len(actions) == 1 {
+		return actions[0], nil
+	}
+
 	// build stmt
 	b := newBlockStmt(char.pos)
 	for _, v := range actions {

pkg/gcs/eval/env.go

@@ -0,0 +1,48 @@
+package eval
+
+type Env struct {
+	parent *Env
+	varMap map[string]*Obj
+}
+
+func NewEnv(parent *Env) *Env {
+	return &Env{
+		parent: parent,
+		varMap: make(map[string]*Obj),
+	}
+}
+
+// put puts a value in the current env regardless of existence or not
+//
+//nolint:gocritic // non-pointer type for *Obj doesn't make sense
+func (e *Env) put(s string, v *Obj) {
+	e.varMap[s] = v
+}
+
+// assign requires variable already exist and assign the value to first instance of variable going up the tree
+//
+//nolint:gocritic // non-pointer type for *Obj doesn't make sense
+func (e *Env) assign(s string, v *Obj) bool {
+	_, ok := e.varMap[s]
+	if !ok {
+		//base case: no parent and does not exist
+		if e.parent == nil {
+			return false
+		}
+		return e.parent.assign(s, v)
+	}
+	e.varMap[s] = v
+	return true
+}
+
+//nolint:gocritic // non-pointer type for *Obj doesn't make sense
+func (e *Env) v(s string) (*Obj, bool) {
+	v, ok := e.varMap[s]
+	if ok {
+		return v, true
+	}
+	if e.parent != nil {
+		return e.parent.v(s)
+	}
+	return nil, false
+}

pkg/gcs/eval/eval.go

@@ -0,0 +1,71 @@
+package eval
+
+import (
+	"errors"
+
+	"github.com/genshinsim/gcsim/pkg/core"
+	"github.com/genshinsim/gcsim/pkg/core/action"
+	"github.com/genshinsim/gcsim/pkg/gcs/ast"
+)
+
+type evalNode interface {
+	// execute the node; node should either return next action, or continue execution until the node is
+	// done. done should only be false if Obj is an action; otherwise must be true
+	nextAction() (Obj, bool, error)
+}
+
+type Evaluator struct {
+	Core *core.Core
+	base evalNode
+	env  *Env
+	err  error
+}
+
+func NewEvaluator(root ast.Node, core *core.Core) (*Evaluator, error) {
+	e := &Evaluator{
+		Core: core,
+		env:  NewEnv(nil),
+	}
+	e.initSysFuncs()
+	e.base = evalFromNode(root, e.env)
+	if e.base == nil {
+		return nil, errors.New("invalid root node; no executor found")
+	}
+	return e, nil
+}
+
+func (e *Evaluator) NextAction() (*action.Eval, error) {
+	// base case: no more action
+	if e.base == nil {
+		return nil, e.err
+	}
+	res, done, err := e.base.nextAction()
+	if err != nil {
+		e.err = err
+		e.base = nil
+		return nil, err
+	}
+	if done {
+		e.base = nil
+	}
+	if v, ok := res.(*actionval); ok {
+		return v.toActionEval(), nil
+	}
+	return nil, nil
+}
+
+func (e *Evaluator) Continue()   {}
+func (e *Evaluator) Exit() error { return nil }
+func (e *Evaluator) Err() error  { return e.err }
+func (e *Evaluator) Start()      {}
+
+func evalFromNode(n ast.Node, env *Env) evalNode {
+	switch v := n.(type) {
+	case ast.Expr:
+		return evalFromExpr(v, env)
+	case ast.Stmt:
+		return evalFromStmt(v, env)
+	default:
+		return nil
+	}
+}

pkg/gcs/eval/eval_map.go

@@ -0,0 +1,55 @@
+package eval
+
+import "github.com/genshinsim/gcsim/pkg/gcs/ast"
+
+func mapExprEval(n *ast.MapExpr, env *Env) evalNode {
+	m := &mapExprEvalNode{
+		root:   n,
+		fields: make(map[string]Obj),
+		stack:  make([]mapFieldWrapper, 0, len(n.Fields)),
+	}
+	// order really doesn't matter here
+	for k, v := range m.root.Fields {
+		m.stack = append(m.stack, mapFieldWrapper{
+			key:  k,
+			node: evalFromExpr(v, env),
+		})
+	}
+	return m
+}
+
+type mapFieldWrapper struct {
+	key  string
+	node evalNode
+}
+
+type mapExprEvalNode struct {
+	root   *ast.MapExpr
+	stack  []mapFieldWrapper
+	fields map[string]Obj
+}
+
+func (m *mapExprEvalNode) nextAction() (Obj, bool, error) {
+	if len(m.root.Fields) == 0 {
+		return &mapval{}, true, nil
+	}
+
+	for len(m.stack) > 0 {
+		idx := len(m.stack) - 1
+		res, done, err := m.stack[idx].node.nextAction()
+		if err != nil {
+			return nil, false, err
+		}
+		if done {
+			m.fields[m.stack[idx].key] = res
+			m.stack = m.stack[:idx]
+		}
+		if res.Typ() == typAction {
+			return res, false, nil // done is false b/c the node is not done yet
+		}
+	}
+
+	return &mapval{
+		fields: m.fields,
+	}, true, nil
+}

pkg/gcs/eval/eval_map_test.go

@@ -0,0 +1,37 @@
+package eval
+
+import (
+	"testing"
+
+	"github.com/genshinsim/gcsim/pkg/gcs/ast"
+)
+
+func TestEvalBasicMapExpr(t *testing.T) {
+	n := &ast.MapExpr{
+		Fields: map[string]ast.Expr{
+			"test": &ast.NumberLit{IntVal: 5},
+		},
+	}
+	val, err := runEvalReturnResWhenDone(evalFromNode(n, nil))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+	v, ok := val.(*mapval)
+	if !ok {
+		t.Errorf("res is not a number, got %v", val.Typ())
+	}
+	res, ok := v.fields["test"]
+	if !ok {
+		t.Errorf("key test does not exist")
+		t.FailNow()
+	}
+	resv, ok := res.(*number)
+	if !ok {
+		t.Errorf("res from map is not a number, got %v", res.Typ())
+		t.FailNow()
+	}
+	if resv.ival != 5 {
+		t.Errorf("expecting result to be %v, got %v", 5, resv.ival)
+	}
+}

pkg/gcs/eval/eval_test.go

@@ -0,0 +1,16 @@
+package eval
+
+import (
+	"errors"
+)
+
+func runEvalReturnResWhenDone(e evalNode) (Obj, error) {
+	if e == nil {
+		return nil, errors.New("invalid root node; no executor found")
+	}
+	val, _, err := e.nextAction()
+	if err != nil {
+		return nil, err
+	}
+	return val, nil
+}

pkg/gcs/eval/expr.go

@@ -0,0 +1,62 @@
+package eval
+
+import (
+	"strings"
+
+	"github.com/genshinsim/gcsim/pkg/gcs/ast"
+)
+
+func evalFromExpr(n ast.Expr, env *Env) evalNode {
+	switch v := n.(type) {
+	case *ast.NumberLit:
+		return numberLitEval(v)
+	case *ast.StringLit:
+		return stringLitEval(v)
+	case *ast.MapExpr:
+		return mapExprEval(v, env)
+	case *ast.BinaryExpr:
+		return binaryExprEval(v, env)
+	case *ast.UnaryExpr:
+		return unaryExprEval(v, env)
+	case *ast.FuncExpr:
+		// FuncExpr is only used for anon funcs, followed after a let stmt
+		return funcExprEval(v, env)
+	case *ast.Ident:
+		return identLitEval(v, env)
+	case *ast.CallExpr:
+		return callExprEval(v, env)
+	case *ast.Field:
+		return fieldsExprEval(v, env)
+	default:
+		return nil
+	}
+}
+
+func numberLitEval(n *ast.NumberLit) evalNode {
+	return &number{
+		isFloat: n.IsFloat,
+		ival:    n.IntVal,
+		fval:    n.FloatVal,
+	}
+}
+
+func stringLitEval(n *ast.StringLit) evalNode {
+	return &strval{
+		str: strings.Trim(n.Value, "\""),
+	}
+}
+
+// funcLitEval is never called directly, but is used by either FuncExpr or FuncStmt, both of which
+// are essentially wrappers around FuncLit
+func funcLitEval(n *ast.FuncLit, env *Env) evalNode {
+	return &funcval{
+		Args:      n.Args,
+		Body:      n.Body,
+		Signature: n.Signature,
+		Env:       NewEnv(env),
+	}
+}
+
+func funcExprEval(n *ast.FuncExpr, env *Env) evalNode {
+	return funcLitEval(n.Func, env)
+}