env[] keyword implemented in parser

checker/checker.go

@@ -132,7 +132,7 @@ func (v *visitor) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info)
 	if fn, ok := v.config.Functions[node.Value]; ok {
 		// Return anyType instead of func type as we don't know the arguments yet.
 		// The func type can be one of the fn.Types. The type will be resolved
-		// when the arguments are known in CallNode.
+		// when the arguments areknown in CallNode.
 		return anyType, info{fn: fn}
 	}
 	if v.config.Types == nil {
@@ -383,6 +383,9 @@ func (v *visitor) ChainNode(node *ast.ChainNode) (reflect.Type, info) {
 }
 
 func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
+	if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "env" {
+		return anyType, info{}
+	}
 	base, _ := v.visit(node.Node)
 	prop, _ := v.visit(node.Property)
 
@@ -429,7 +432,9 @@ func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 		return t, info{}
 
 	case reflect.Array, reflect.Slice:
-		if !isInteger(prop) && !isAny(prop) {
+		if isInteger(prop) || isAny(prop) {
+			// ok, we normally expect an integer or interface that could be one
+		} else {
 			return v.error(node.Property, "array elements can only be selected using an integer (got %v)", prop)
 		}
 		t, c := deref(base.Elem())

compiler/compiler.go

@@ -491,19 +491,25 @@ func (c *compiler) MemberNode(node *ast.MemberNode) {
 		}
 	}
 
-	c.compile(base)
-	if node.Optional {
-		ph := c.emit(OpJumpIfNil, placeholder)
-		c.chains[len(c.chains)-1] = append(c.chains[len(c.chains)-1], ph)
-	}
-
-	if op == OpFetch {
+	// Implementation of direct env access
+	if ident, ok := base.(*ast.IdentifierNode); ok && ident.Value == "env" {
 		c.compile(node.Property)
-		c.emit(OpFetch)
+		c.emit(OpFetchEnv)
 	} else {
-		c.emitLocation(node.Location(), op, c.addConstant(
-			&runtime.Field{Index: index, Path: path},
-		))
+		c.compile(base)
+		if node.Optional {
+			ph := c.emit(OpJumpIfNil, placeholder)
+			c.chains[len(c.chains)-1] = append(c.chains[len(c.chains)-1], ph)
+		}
+
+		if op == OpFetch {
+			c.compile(node.Property)
+			c.emit(OpFetch)
+		} else {
+			c.emitLocation(node.Location(), op, c.addConstant(
+				&runtime.Field{Index: index, Path: path},
+			))
+		}
 	}
 
 deref:

expr_test.go

@@ -1811,6 +1811,97 @@ func TestEval_nil_in_maps(t *testing.T) {
 	})
 }
 
+// Test the use of env keyword.  Forms env[] and env[”] are valid.
+// The enclosed identifier must be in the expression env.
+func TestEnv_keyword(t *testing.T) {
+	env := map[string]interface{}{
+		"space test":                       "ok",
+		"space_test":                       "not ok", // Seems to be some underscore substituting happening, check that.
+		"Section 1-2a":                     "ok",
+		`c:\ndrive\2015 Information Table`: "ok",
+		"%*worst function name ever!!": func() string {
+			return "ok"
+		}(),
+		"env": func(string) string {
+			return "num"
+		},
+		"1":       "o",
+		"2":       "k",
+		"num":     10,
+		"my list": []int{1, 2, 3, 4, 5},
+		"MIN": func(a, b int) int {
+			if a < b {
+				return a
+			} else {
+				return b
+			}
+		},
+		"red":   "n",
+		"irect": "um",
+	}
+
+	// No error cases
+	var tests = []struct {
+		code string
+		want interface{}
+	}{
+		{"env['space test']", "ok"},
+		{"env['Section 1-2a']", "ok"},
+		{`env["c:\\ndrive\\2015 Information Table"]`, "ok"},
+		{"env['%*worst function name ever!!']", "ok"},
+		{"env('Confusing!')", "num"}, // not keyword, but some function named env
+		{"env['1'] + env['2']", "ok"},
+		{"1 + env['num'] + env['num']", 21},
+		{"MIN(env['num'],0)", 0},
+		{"env['nu' + 'm']", 10},
+		{"env[red + irect]", 10},
+		{"env[env('na')]", 10},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+
+			program, err := expr.Compile(tt.code, expr.Env(env))
+			require.NoError(t, err, "compile error")
+
+			got, err := expr.Run(program, env)
+			require.NoError(t, err, "execution error")
+
+			assert.Equal(t, tt.want, got, tt.code)
+		})
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+			got, err := expr.Eval(tt.code, env)
+			require.NoError(t, err, "eval error: "+tt.code)
+
+			assert.Equal(t, tt.want, got, "eval: "+tt.code)
+		})
+	}
+
+	// error cases
+	tests = []struct {
+		code string
+		want interface{}
+	}{
+		{"env[this is a problem", "bad"},
+		{"env['also a problem'", "bad"},
+		{"env[space test]", "bad"},
+		{"env[1] + env[2]", "bad"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.code, func(t *testing.T) {
+
+			_, err := expr.Eval(tt.code, expr.Env(env))
+			require.Error(t, err, "compile error")
+
+		})
+	}
+
+}
+
 type Bar interface {
 	Bar() int
 }

vm/opcodes.go

@@ -13,6 +13,7 @@ const (
 	OpLoadFunc
 	OpFetch
 	OpFetchField
+	OpFetchEnv
 	OpMethod
 	OpTrue
 	OpFalse

vm/vm.go

@@ -123,6 +123,13 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 			a := vm.pop()
 			vm.push(runtime.FetchField(a, program.Constants[arg].(*runtime.Field)))
 
+		case OpFetchEnv:
+			b := vm.pop()
+			if _, ok := b.(string); !ok {
+				panic("index for env[] keyord must be string")
+			}
+			vm.push(runtime.Fetch(env, b))
+
 		case OpMethod:
 			a := vm.pop()
 			vm.push(runtime.FetchMethod(a, program.Constants[arg].(*runtime.Method)))