Add support for indexing into variables

This adds support for indexing into variables of the new type "List".
The syntax is typical C-style array syntax, so for example, the
following is valid for interpolating the element of the list in variable
foo at position 1:

    "${foo[1]}"

There is a restriction that lists must be homogenous in type. This is to
enable the type checker to work without having to actually perform the
indexing operation. During discussion there was no compelling use case
for lists of heterogenous types - this is open for discussion in future
though if one is found.

.gitignore

@@ -1 +1,3 @@
 .DS_Store
+.idea
+*.iml

ast/ast.go

@@ -52,4 +52,5 @@ const (
 	TypeString
 	TypeInt
 	TypeFloat
+	TypeList
 )

ast/index.go

@@ -0,0 +1,68 @@
+package ast
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Index represents an indexing operation into another data structure
+type Index struct {
+	Target Node
+	Key    Node
+	Posx   Pos
+}
+
+func (n *Index) Accept(v Visitor) Node {
+	return v(n)
+}
+
+func (n *Index) Pos() Pos {
+	return n.Posx
+}
+
+func (n *Index) String() string {
+	return fmt.Sprintf("Index(%s, %s)", n.Target, n.Key)
+}
+
+func (n *Index) Type(s Scope) (Type, error) {
+	variableAccess, ok := n.Target.(*VariableAccess)
+	if !ok {
+		return TypeInvalid, fmt.Errorf("target is not a variable")
+	}
+
+	variable, ok := s.LookupVar(variableAccess.Name)
+	if !ok {
+		return TypeInvalid, fmt.Errorf("unknown variable accessed: %s", variableAccess.Name)
+	}
+	if variable.Type != TypeList {
+		return TypeInvalid, fmt.Errorf("invalid index operation into non-indexable type: %s", variable.Type)
+	}
+
+	list := variable.Value.([]Variable)
+
+	// Ensure that the types of the list elements are homogenous
+	listTypes := make(map[Type]struct{})
+	for _, v := range list {
+		if _, ok := listTypes[v.Type]; ok {
+			continue
+		}
+		listTypes[v.Type] = struct{}{}
+	}
+
+	if len(listTypes) != 1 {
+		typesFound := make([]string, len(listTypes))
+		i := 0
+		for k, _ := range listTypes {
+			typesFound[0] = k.String()
+			i++
+		}
+		types := strings.Join(typesFound, ", ")
+		return TypeInvalid, fmt.Errorf("list %q does not have homogenous types. found %s", variableAccess.Name, types)
+	}
+
+	return list[0].Type, nil
+}
+
+func (n *Index) GoString() string {
+	return fmt.Sprintf("*%#v", *n)
+}

ast/index_test.go

@@ -0,0 +1,110 @@
+package ast
+
+import (
+	"testing"
+)
+
+func TestIndexType_string(t *testing.T) {
+	i := &Index{
+		Target: &VariableAccess{Name: "foo"},
+		Key: &LiteralNode{
+			Typex: TypeInt,
+			Value: 1,
+		},
+	}
+
+	scope := &BasicScope{
+		VarMap: map[string]Variable{
+			"foo": Variable{
+				Type: TypeList,
+				Value: []Variable{
+					Variable{
+						Type:  TypeString,
+						Value: "Hello",
+					},
+					Variable{
+						Type:  TypeString,
+						Value: "World",
+					},
+				},
+			},
+		},
+	}
+
+	actual, err := i.Type(scope)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	if actual != TypeString {
+		t.Fatalf("bad: %s", actual)
+	}
+}
+
+func TestIndexType_int(t *testing.T) {
+	i := &Index{
+		Target: &VariableAccess{Name: "foo"},
+		Key: &LiteralNode{
+			Typex: TypeInt,
+			Value: 1,
+		},
+	}
+
+	scope := &BasicScope{
+		VarMap: map[string]Variable{
+			"foo": Variable{
+				Type: TypeList,
+				Value: []Variable{
+					Variable{
+						Type:  TypeInt,
+						Value: 34,
+					},
+					Variable{
+						Type:  TypeInt,
+						Value: 54,
+					},
+				},
+			},
+		},
+	}
+
+	actual, err := i.Type(scope)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	if actual != TypeInt {
+		t.Fatalf("bad: %s", actual)
+	}
+}
+
+func TestIndexType_nonHomogenous(t *testing.T) {
+	i := &Index{
+		Target: &VariableAccess{Name: "foo"},
+		Key: &LiteralNode{
+			Typex: TypeInt,
+			Value: 1,
+		},
+	}
+
+	scope := &BasicScope{
+		VarMap: map[string]Variable{
+			"foo": Variable{
+				Type: TypeList,
+				Value: []Variable{
+					Variable{
+						Type:  TypeString,
+						Value: "Hello",
+					},
+					Variable{
+						Type:  TypeInt,
+						Value: 43,
+					},
+				},
+			},
+		},
+	}
+
+	_, err := i.Type(scope)
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+}

ast/scope.go

@@ -33,6 +33,12 @@ func NewVariable(v interface{}) (result Variable, err error) {
 	return
 }
 
+// String implements Stringer on Variable, displaying the type and value
+// of the Variable.
+func (v Variable) String() string {
+	return fmt.Sprintf("{Variable (%s): %+v}", v.Type, v.Value)
+}
+
 // Function defines a function that can be executed by the engine.
 // The type checker will validate that the proper types will be called
 // to the callback.

ast/scope_test.go

@@ -37,3 +37,18 @@ func TestBasicScopeLookupVar(t *testing.T) {
 		t.Fatal("should find foo")
 	}
 }
+
+func TestVariableStringer(t *testing.T) {
+	expected := "{Variable (TypeInt): 42}"
+	variable := &Variable{
+		Type:  TypeInt,
+		Value: 42,
+	}
+
+	actual := variable.String()
+
+	if actual != expected {
+		t.Fatalf("variable string formatting:\nExpected: %s\n     Got: %s\n",
+			expected, actual)
+	}
+}

ast/variable_access_test.go

@@ -34,3 +34,20 @@ func TestVariableAccessType_invalid(t *testing.T) {
 		t.Fatal("should error")
 	}
 }
+
+func TestVariableAccessType_list(t *testing.T) {
+	c := &VariableAccess{Name: "baz"}
+	scope := &BasicScope{
+		VarMap: map[string]Variable{
+			"baz": Variable{Type: TypeList},
+		},
+	}
+
+	actual, err := c.Type(scope)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	if actual != TypeList {
+		t.Fatalf("bad: %s", actual)
+	}
+}

check_types.go

@@ -61,6 +61,9 @@ func (v *TypeCheck) visit(raw ast.Node) ast.Node {
 	case *ast.Call:
 		tc := &typeCheckCall{n}
 		result, err = tc.TypeCheck(v)
+	case *ast.Index:
+		tc := &typeCheckIndex{n}
+		result, err = tc.TypeCheck(v)
 	case *ast.Concat:
 		tc := &typeCheckConcat{n}
 		result, err = tc.TypeCheck(v)
@@ -285,6 +288,55 @@ func (tc *typeCheckVariableAccess) TypeCheck(v *TypeCheck) (ast.Node, error) {
 	return tc.n, nil
 }
 
+type typeCheckIndex struct {
+	n *ast.Index
+}
+
+func (tc *typeCheckIndex) TypeCheck(v *TypeCheck) (ast.Node, error) {
+
+	value, err := tc.n.Key.Type(v.Scope)
+	if err != nil {
+		return nil, err
+	}
+	if value != ast.TypeInt {
+		return nil, fmt.Errorf("key of an index must be an int, was %s", value)
+	}
+
+	// Ensure we have a VariableAccess as the target
+	varAccessNode, ok := tc.n.Target.(*ast.VariableAccess)
+	if !ok {
+		return nil, fmt.Errorf("target of an index must be a VariableAccess node, was %T", tc.n.Target)
+	}
+
+	// Get the variable
+	variable, ok := v.Scope.LookupVar(varAccessNode.Name)
+	if !ok {
+		return nil, fmt.Errorf("unknown variable accessed: %s", varAccessNode.Name)
+	}
+	if variable.Type != ast.TypeList {
+		return nil, fmt.Errorf("invalid index operation into non-indexable type: %s", variable.Type)
+	}
+
+	list := variable.Value.([]ast.Variable)
+
+	// Ensure that the types of the list elements are homogenous
+	listTypes := make(map[ast.Type]struct{})
+	for _, v := range list {
+		if _, ok := listTypes[v.Type]; ok {
+			continue
+		}
+		listTypes[v.Type] = struct{}{}
+	}
+
+	if len(listTypes) != 1 {
+		return nil, fmt.Errorf("list %q does not have homogenous types (%s)", varAccessNode.Name)
+	}
+
+	// This is the type since the list is homogenous in type
+	v.StackPush(list[0].Type)
+	return tc.n, nil
+}
+
 func (v *TypeCheck) ImplicitConversion(
 	actual ast.Type, expected ast.Type, n ast.Node) ast.Node {
 	if v.Implicit == nil {