ast.Array should cache groundness bit to avoid unnecessary computation

[tsandall]

The ast.Array structure does not memoize groundness. As a result, checks for groundness have to recompute for all elements which can be expensive for large arrays.

Related: 00be8a2

[srenatus]

This is a little hairier with arrays compared to sets: when slicing an array, the elements are still shared. So

1. the slice could have a different groundness than the original
2. changes to the slice could change the original's groundness

Still worth improving, of course. 👍

[srenatus]

Looking further into this, the evalTerm's get/next/enumerate code path isn't the same for array as it is for sets and objects,

opa/topdown/eval.go

Lines 2709 to 2731 in 8fc2ba1

	case *ast.Array:
	for i := 0; i < v.Len(); i++ {
	k := ast.IntNumberTerm(i)
	err := e.e.biunify(k, e.ref[e.pos], e.bindings, e.bindings, func() error {
	return e.next(iter, k)
	})
	if err != nil {
	return err
	}
	}
	case ast.Object:
	return v.Iter(func(k, _ *ast.Term) error {
	return e.e.biunify(k, e.ref[e.pos], e.termbindings, e.bindings, func() error {
	return e.next(iter, e.termbindings.Plug(k))
	})
	})
	case ast.Set:
	return v.Iter(func(elem *ast.Term) error {
	return e.e.biunify(elem, e.ref[e.pos], e.termbindings, e.bindings, func() error {
	return e.next(iter, e.termbindings.Plug(elem))
	})
	})
	}

we'll get a Number term for the index here, and feed that into get,

opa/topdown/eval.go

Lines 2777 to 2782 in 8fc2ba1

	case *ast.Array:
	term := v.Get(plugged)
	if term != nil {
	return e.termbindings.apply(term)
	}
	}

without any checks for groundness.