evaluator: Add index and dot expression evaluation

Add index and dot expression evaluation in evaluator, similar to binary
expression evaluation.

Author: juliaogris

pkg/evaluator/evaluator.go

@@ -67,6 +67,10 @@ func (e *Evaluator) Eval(scope *scope, node parser.Node) Value {
 		return e.evalUnaryExpr(scope, node)
 	case *parser.BinaryExpression:
 		return e.evalBinaryExpr(scope, node)
+	case *parser.IndexExpression:
+		return e.evalIndexExpr(scope, node)
+	case *parser.DotExpression:
+		return e.evalDotExpr(scope, node)
 	}
 	return nil
 }
@@ -341,3 +345,40 @@ func evalBinaryBoolExpr(op parser.Operator, left, right *Bool) Value {
 	}
 	return newError("unknown bool operation: " + op.String())
 }
+
+func (e *Evaluator) evalIndexExpr(scope *scope, expr *parser.IndexExpression) Value {
+	left := e.Eval(scope, expr.Left)
+	if isError(left) {
+		return left
+	}
+	index := e.Eval(scope, expr.Index)
+	if isError(index) {
+		return index
+	}
+
+	switch left := left.(type) {
+	case *Array:
+		return left.Index(index)
+	case *String:
+		return left.Index(index)
+	case *Map:
+		index, ok := index.(*String)
+		if !ok {
+			return newError("expected string for map index, found " + index.String())
+		}
+		return left.Get(index.Val)
+	}
+	return nil
+}
+
+func (e *Evaluator) evalDotExpr(scope *scope, expr *parser.DotExpression) Value {
+	left := e.Eval(scope, expr.Left)
+	if isError(left) {
+		return left
+	}
+	m, ok := left.(*Map)
+	if !ok {
+		return newError("expected map before '.', found " + left.String())
+	}
+	return m.Get(expr.Key)
+}

pkg/evaluator/evaluator_test.go

@@ -317,6 +317,60 @@ a := [1 1+1 (three)]`: "[1 2 3]",
 	}
 }
 
+func TestIndex(t *testing.T) {
+	tests := map[string]string{
+		// x := ["a","b","c"]; x = "abc"
+		"print x[0]":  "a",
+		"print x[1]":  "b",
+		"print x[2]":  "c",
+		"print x[-1]": "c",
+		"print x[-2]": "b",
+		"print x[-3]": "a",
+		`
+		n1 := 1
+		print x[n1 - 1] x[1 + n1]
+		`: "a c",
+		`
+		m := {a: "bingo"}
+		print m[x[0]]
+		`: "bingo",
+	}
+	for in, want := range tests {
+		in, want := in, want
+		for _, decl := range []string{`x := ["a" "b" "c"]`, `x := "abc"`} {
+			input := decl + "\n" + in
+			t.Run(input, func(t *testing.T) {
+				b := bytes.Buffer{}
+				fn := func(s string) { b.WriteString(s) }
+				Run(input, fn)
+				assert.Equal(t, want+"\n", b.String())
+			})
+		}
+	}
+}
+
+func TestIndexErr(t *testing.T) {
+	tests := map[string]string{
+		// x := ["a","b","c"]; x = "abc"
+		"print x[3]":  "ERROR: index 3 out of bounds, should be between -3 and 2",
+		"print x[-4]": "ERROR: index -4 out of bounds, should be between -3 and 2",
+		`m := {}
+		print m[x[1]]`: "ERROR: no value for key b",
+	}
+	for in, want := range tests {
+		in, want := in, want
+		for _, decl := range []string{`x := ["a" "b" "c"]`, `x := "abc"`} {
+			input := decl + "\n" + in
+			t.Run(input, func(t *testing.T) {
+				b := bytes.Buffer{}
+				fn := func(s string) { b.WriteString(s) }
+				Run(input, fn)
+				assert.Equal(t, want, b.String())
+			})
+		}
+	}
+}
+
 func TestMapLit(t *testing.T) {
 	tests := map[string]string{
 		"a := {n:1}":                 "{n:1}",
@@ -344,6 +398,26 @@ a := {name:"fox" age:39+(three)}`: "{name:fox age:42}",
 	}
 }
 
+func TestDot(t *testing.T) {
+	tests := map[string]string{
+		// m := {name: "Greta"}
+		"print m.name":    "Greta",
+		`print m["name"]`: "Greta",
+		`s := "name"
+		print m[s]`: "Greta",
+	}
+	for in, want := range tests {
+		in, want := in, want
+		input := `m := {name: "Greta"}` + "\n" + in
+		t.Run(input, func(t *testing.T) {
+			b := bytes.Buffer{}
+			fn := func(s string) { b.WriteString(s) }
+			Run(input, fn)
+			assert.Equal(t, want+"\n", b.String())
+		})
+	}
+}
+
 func TestDemo(t *testing.T) {
 	prog := `
 move 10 10

pkg/evaluator/value.go

@@ -61,7 +61,8 @@ type Bool struct {
 }
 
 type String struct {
-	Val string
+	Val   string
+	runes []rune
 }
 
 type Any struct {
@@ -115,9 +116,21 @@ func (s *String) Equals(v Value) bool {
 func (s *String) Set(v Value) {
 	if s2, ok := v.(*String); ok {
 		s.Val = s2.Val
+		s.runes = nil
 	}
 }
 
+func (s *String) Index(idx Value) Value {
+	if s.runes == nil {
+		s.runes = []rune(s.Val)
+	}
+	i, err := normalizeIndex(idx, len(s.runes))
+	if err != nil {
+		return err
+	}
+	return &String{Val: string(s.runes[i])}
+}
+
 func (*Bool) Type() ValueType { return BOOL }
 func (b *Bool) String() string {
 	return strconv.FormatBool(b.Val)
@@ -196,6 +209,15 @@ func (a *Array) Set(v Value) {
 	}
 }
 
+func (a *Array) Index(idx Value) Value {
+	i, err := normalizeIndex(idx, len(*a.Elements))
+	if err != nil {
+		return err
+	}
+	elements := *a.Elements
+	return elements[i]
+}
+
 func (m *Map) Type() ValueType { return MAP }
 func (m *Map) String() string {
 	pairs := make([]string, 0, len(m.Pairs))
@@ -228,6 +250,14 @@ func (m *Map) Set(v Value) {
 	}
 }
 
+func (m *Map) Get(key string) Value {
+	val, ok := m.Pairs[key]
+	if !ok {
+		return newError("no value for key " + key)
+	}
+	return val
+}
+
 func isError(val Value) bool { // TODO: replace with panic flow
 	return val != nil && val.Type() == ERROR
 }
@@ -243,3 +273,20 @@ func isBreak(val Value) bool {
 func newError(msg string) *Error {
 	return &Error{Message: msg}
 }
+
+func normalizeIndex(idx Value, length int) (int, Value) {
+	index, ok := idx.(*Num)
+	if !ok {
+		return 0, newError("expected index of type num, found " + idx.Type().String())
+	}
+	i := int(index.Val)
+	if i < -length || i >= length {
+		boundsStr := strconv.Itoa(-length) + " and " + strconv.Itoa(length-1)
+		msg := "index " + strconv.Itoa(i) + " out of bounds, should be between " + boundsStr
+		return 0, newError(msg)
+	}
+	if i < 0 {
+		return length + i, nil // -1 references len-1 i.e. last element
+	}
+	return i, nil
+}