Merge branch 'expr-lang:master' into master

Author: zhuliquan

.github/scripts/coverage.mjs

@@ -1,11 +1,14 @@
-#!/usr/bin/env zx --experimental
+#!/usr/bin/env zx
 
 const expected = 90
 const exclude = [
   'expr/test',
   'checker/mock',
   'vm/func_types',
   'vm/runtime/helpers',
+  'internal/difflib',
+  'internal/spew',
+  'internal/testify',
 ]
 
 cd(path.resolve(__dirname, '..', '..'))
@@ -24,9 +27,11 @@ await spinner('Running tests', async () => {
   await $`go tool cover -html=coverage.out -o coverage.html`
 })
 
-const cover = await $`go tool cover -func=coverage.out`
+const cover = await $({verbose: true})`go tool cover -func=coverage.out`
 const total = +cover.stdout.match(/total:\s+\(statements\)\s+(\d+\.\d+)%/)[1]
 if (total < expected) {
   echo(chalk.red(`Coverage is too low: ${total}% < ${expected}% (expected)`))
   process.exit(1)
+} else {
+  echo(`Coverage is good: ${chalk.green(total + '%')} >= ${expected}% (expected)`)
 }

.github/workflows/build.yml

@@ -0,0 +1,23 @@
+name: build
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-versions: [ '1.18', '1.22' ]
+        go-arch: [ '386' ]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Go ${{ matrix.go-version }}
+        uses: actions/setup-go@v4
+        with:
+          go-version: ${{ matrix.go-version }}
+      - name: Build
+        run: GOARCH=${{ matrix.go-arch }} go build

.github/workflows/check.yml

@@ -16,4 +16,4 @@ jobs:
         with:
           go-version: 1.18
       - name: Test
-        run: npx zx --experimental .github/scripts/coverage.mjs
+        run: npx zx .github/scripts/coverage.mjs

.github/workflows/test.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.18', '1.19', '1.20', '1.21' ]
+        go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22' ]
     steps:
       - uses: actions/checkout@v3
       - name: Setup Go ${{ matrix.go-version }}

README.md

@@ -162,6 +162,9 @@ func main() {
 * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
 * [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling.
+* [Span Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products.
+* [Xiaohongshu](https://www.xiaohongshu.com/) combining yaml with Expr for dynamically policies delivery.
+* [Melrōse](https://melrōse.org) uses Expr to implement its music programming language.
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

ast/node.go

@@ -3,13 +3,20 @@ package ast
 import (
 	"reflect"
 
+	"github.com/expr-lang/expr/checker/nature"
 	"github.com/expr-lang/expr/file"
 )
 
+var (
+	anyType = reflect.TypeOf(new(any)).Elem()
+)
+
 // Node represents items of abstract syntax tree.
 type Node interface {
 	Location() file.Location
 	SetLocation(file.Location)
+	Nature() nature.Nature
+	SetNature(nature.Nature)
 	Type() reflect.Type
 	SetType(reflect.Type)
 	String() string
@@ -25,8 +32,8 @@ func Patch(node *Node, newNode Node) {
 
 // base is a base struct for all nodes.
 type base struct {
-	loc      file.Location
-	nodeType reflect.Type
+	loc    file.Location
+	nature nature.Nature
 }
 
 // Location returns the location of the node in the source code.
@@ -39,14 +46,27 @@ func (n *base) SetLocation(loc file.Location) {
 	n.loc = loc
 }
 
+// Nature returns the nature of the node.
+func (n *base) Nature() nature.Nature {
+	return n.nature
+}
+
+// SetNature sets the nature of the node.
+func (n *base) SetNature(nature nature.Nature) {
+	n.nature = nature
+}
+
 // Type returns the type of the node.
 func (n *base) Type() reflect.Type {
-	return n.nodeType
+	if n.nature.Type == nil {
+		return anyType
+	}
+	return n.nature.Type
 }
 
 // SetType sets the type of the node.
 func (n *base) SetType(t reflect.Type) {
-	n.nodeType = t
+	n.nature.Type = t
 }
 
 // NilNode represents nil.
@@ -163,13 +183,13 @@ type BuiltinNode struct {
 	Map       Node   // Used by optimizer to fold filter() and map() builtins.
 }
 
-// ClosureNode represents a predicate.
+// PredicateNode represents a predicate.
 // Example:
 //
 //	filter(foo, .bar == 1)
 //
 // The predicate is ".bar == 1".
-type ClosureNode struct {
+type PredicateNode struct {
 	base
 	Node Node // Node of the predicate body.
 }

ast/print.go

@@ -65,8 +65,7 @@ func (n *BinaryNode) String() string {
 	var lhs, rhs string
 	var lwrap, rwrap bool
 
-	lb, ok := n.Left.(*BinaryNode)
-	if ok {
+	if lb, ok := n.Left.(*BinaryNode); ok {
 		if operator.Less(lb.Operator, n.Operator) {
 			lwrap = true
 		}
@@ -77,9 +76,7 @@ func (n *BinaryNode) String() string {
 			lwrap = true
 		}
 	}
-
-	rb, ok := n.Right.(*BinaryNode)
-	if ok {
+	if rb, ok := n.Right.(*BinaryNode); ok {
 		if operator.Less(rb.Operator, n.Operator) {
 			rwrap = true
 		}
@@ -88,6 +85,13 @@ func (n *BinaryNode) String() string {
 		}
 	}
 
+	if _, ok := n.Left.(*ConditionalNode); ok {
+		lwrap = true
+	}
+	if _, ok := n.Right.(*ConditionalNode); ok {
+		rwrap = true
+	}
+
 	if lwrap {
 		lhs = fmt.Sprintf("(%s)", n.Left.String())
 	} else {
@@ -108,20 +112,25 @@ func (n *ChainNode) String() string {
 }
 
 func (n *MemberNode) String() string {
+	node := n.Node.String()
+	if _, ok := n.Node.(*BinaryNode); ok {
+		node = fmt.Sprintf("(%s)", node)
+	}
+
 	if n.Optional {
 		if str, ok := n.Property.(*StringNode); ok && utils.IsValidIdentifier(str.Value) {
-			return fmt.Sprintf("%s?.%s", n.Node.String(), str.Value)
+			return fmt.Sprintf("%s?.%s", node, str.Value)
 		} else {
-			return fmt.Sprintf("%s?.[%s]", n.Node.String(), n.Property.String())
+			return fmt.Sprintf("%s?.[%s]", node, n.Property.String())
 		}
 	}
 	if str, ok := n.Property.(*StringNode); ok && utils.IsValidIdentifier(str.Value) {
 		if _, ok := n.Node.(*PointerNode); ok {
 			return fmt.Sprintf(".%s", str.Value)
 		}
-		return fmt.Sprintf("%s.%s", n.Node.String(), str.Value)
+		return fmt.Sprintf("%s.%s", node, str.Value)
 	}
-	return fmt.Sprintf("%s[%s]", n.Node.String(), n.Property.String())
+	return fmt.Sprintf("%s[%s]", node, n.Property.String())
 }
 
 func (n *SliceNode) String() string {
@@ -153,7 +162,7 @@ func (n *BuiltinNode) String() string {
 	return fmt.Sprintf("%s(%s)", n.Name, strings.Join(arguments, ", "))
 }
 
-func (n *ClosureNode) String() string {
+func (n *PredicateNode) String() string {
 	return n.Node.String()
 }
 
@@ -206,7 +215,7 @@ func (n *PairNode) String() string {
 		if utils.IsValidIdentifier(str.Value) {
 			return fmt.Sprintf("%s: %s", str.Value, n.Value.String())
 		}
-		return fmt.Sprintf("%q: %s", str.String(), n.Value.String())
+		return fmt.Sprintf("%s: %s", str.String(), n.Value.String())
 	}
 	return fmt.Sprintf("(%s): %s", n.Key.String(), n.Value.String())
 }

ast/print_test.go

@@ -3,8 +3,8 @@ package ast_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
 
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/parser"
@@ -57,6 +57,10 @@ func TestPrint(t *testing.T) {
 		{`{}`, `{}`},
 		{`{a: b}`, `{a: b}`},
 		{`{a: b, c: d}`, `{a: b, c: d}`},
+		{`{"a": b, 'c': d}`, `{a: b, c: d}`},
+		{`{"a": b, c: d}`, `{a: b, c: d}`},
+		{`{"a": b, 8: 8}`, `{a: b, "8": 8}`},
+		{`{"9": 9, '8': 8, "foo": d}`, `{"9": 9, "8": 8, foo: d}`},
 		{`[]`, `[]`},
 		{`[a]`, `[a]`},
 		{`[a, b]`, `[a, b]`},
@@ -72,6 +76,7 @@ func TestPrint(t *testing.T) {
 		{`a[:]`, `a[:]`},
 		{`(nil ?? 1) > 0`, `(nil ?? 1) > 0`},
 		{`{("a" + "b"): 42}`, `{("a" + "b"): 42}`},
+		{`(One == 1 ? true : false) && Two == 2`, `(One == 1 ? true : false) && Two == 2`},
 	}
 
 	for _, tt := range tests {

ast/visitor.go

@@ -7,6 +7,9 @@ type Visitor interface {
 }
 
 func Walk(node *Node, v Visitor) {
+	if *node == nil {
+		return
+	}
 	switch n := (*node).(type) {
 	case *NilNode:
 	case *IdentifierNode:
@@ -42,7 +45,7 @@ func Walk(node *Node, v Visitor) {
 		for i := range n.Arguments {
 			Walk(&n.Arguments[i], v)
 		}
-	case *ClosureNode:
+	case *PredicateNode:
 		Walk(&n.Node, v)
 	case *PointerNode:
 	case *VariableDeclaratorNode:

ast/visitor_test.go

@@ -3,8 +3,9 @@ package ast_test
 import (
 	"testing"
 
+	"github.com/expr-lang/expr/internal/testify/assert"
+
 	"github.com/expr-lang/expr/ast"
-	"github.com/stretchr/testify/assert"
 )
 
 type visitor struct {