Fix fn:not() predicate crashes on empty context and atomic sequences

[joewiz]

Summary

Fixes two long-standing bugs in fn:not() that cause unexpected errors when used in predicates:

• Weird "cannot convert xs:boolean('true') to a node set" message #2159: $doc/*[not(self::abc)] throws "cannot convert xs:boolean('true') to a node set" when $doc resolves to empty
• not() function failing on boolean sequence #2308: (true(), false())[not(.)] throws err:FORG0006 instead of returning (false())

Both stem from optimizations in FunNot that assume node-set contexts but encounter empty sets or atomic values. These bugs have been open since 2018.

The FunNot.getDependencies() fix for #2308 also fixes #3289: @*[name() ! contains(., 'DateTime')] throws "the sequence cannot be converted into a node set. Item type is xs:boolean" on persistent (stored) documents. The fix ensures not(.) reports CONTEXT_ITEM dependency inside predicates, which prevents Predicate.recomputeExecutionMode() from pre-evaluating not(.) against the full context sequence.

Approach

Per @wolfgangmm's concern: "eXist handles fn:not in a particular way by trying to evaluate it as a set operation. A naive fix would likely result in many expressions becoming slower by an order of magnitude."

These fixes preserve the set-difference optimization for all performance-critical patterns ([not(child)], [not(@attr)], [not(descendant::x)], [not(self::element)]).

Changes

Fix #2159 — FunNot.eval() empty-context guard

When fn:not() is used inside a predicate and the context sequence is empty, the set-difference path returned a BooleanValue which Predicate.selectByNodeSet() cannot consume. Fix: return EMPTY_SEQUENCE when in a predicate with empty context (filtering an empty set always yields empty). Outside predicates, the boolean path is preserved. This matches the intent of the original commented-out TODO code.

Fix #2308 — FunNot.getDependencies() targeted CONTEXT_ITEM

LocationStep.getDependencies() suppresses CONTEXT_ITEM for the self axis inside predicates to enable the set-difference optimization. This is correct for node-set predicates but causes not(.) on atomic sequences to be pre-evaluated against the full sequence instead of item-by-item, throwing FORG0006.

Fix: FunNot.getDependencies() adds CONTEXT_ITEM to the dependency flags when the argument is the context item expression . — specifically, a LocationStep with SELF_AXIS and a node() type test — and the function is inside a predicate. This is targeted and narrow: it only affects . (self::node()), not typed self-axis steps like self::element, forcing Predicate to use per-item boolean evaluation for that specific case. All other predicates (not(child::bar), not(@attr), not(descendant::x), not(self::element)) are unaffected because their arguments use different axes, different type tests, or are not LocationStep instances.

FunNot.returnsType() and LocationStep.getDependencies() are unchanged from develop.

Why the set-difference optimization is preserved

The optimization in FunNot.eval() runs when the argument returns NODE, context is a persistent set, and argument has no CONTEXT_ITEM dependency. After these changes:

Pattern	Arg depends on CONTEXT_ITEM?	Set-difference?	Notes
[not(child::bar)]	No	Yes	Unchanged
[not(@attr)]	No	Yes	Unchanged
[not(descendant::x)]	No	Yes	Unchanged
[not(self::abc)]	No (element type test, not node())	Yes	Unchanged
[not(.)] on atomics	Yes (self::node(), inPredicate)	No — boolean	Correct, was erroring before
[not(.)] on nodes	Yes (self::node(), inPredicate)	No — boolean	Trivial pattern, not perf-sensitive

The promotion path via Predicate.recomputeExecutionMode() is unchanged.

Performance benchmark

FunNotBenchmark.java measures 5 query patterns (100 warmup + 500 measured iterations each) against a 200-item generated XML document with no indexes (structural index only).

Run with:

mvn test -pl exist-core -Dtest=FunNotBenchmark \
    -Dexist.run.benchmarks=true -Ddependency-check.skip=true

Results

Query	develop avg (ms)	PR avg (ms)	develop ops/s	PR ops/s
//item[not(child)]	0.277	0.270	3,609	3,698
//item[not(@attr)]	0.277	0.263	3,608	3,804
//item[not(descendant::x)]	0.266	0.262	3,756	3,821
//item[not(.)]	0.261	0.247	3,838	4,044
//item[not(@id > 100)]	0.724	0.720	1,382	1,388

Takeaway: All queries are within noise margin (~2%). The set-difference optimization is fully preserved for child, attribute, and descendant axis patterns. The not(.) pattern (boolean fallback path) also shows no regression. Environment: macOS, Zulu JDK 21, single-threaded, in-process embedded server.

Test plan

• New fn-not.xq XQSuite tests covering empty paths, persistent node set-difference, not(.) on integers/strings/booleans/nodes
• Removed %test:pending from boolseq:countNegativesContextItem in boolean-sequences.xq
• New simple-map-predicate.xq tests for Type error: eXist misreads an XPath node sequence with a predicate as xs:boolean [BUG] #3289: @*[name() ! contains(., 'DateTime')] on persistent and in-memory documents
• Performance benchmark (FunNotBenchmark.java): 5 queries × 500 iterations, no regression vs develop
• Full CoreTests suite: 992 tests, 0 failures, 0 errors
• OptimizerTest: 6 tests, 0 failures
• DateTest: 46 tests, 0 failures

🤖 Generated with Claude Code

[joewiz]

[This comment was co-authored with Claude Code. -Joe]

Closing — superseded by #6207 (v2/xq31-compliance-fixes).

This work has been consolidated into a clean v2/ branch as part of the eXist-db 7.0 PR reorganization. The new PR includes all commits from this PR plus additional related work, with reviewer feedback incorporated where applicable. See the reviewer guide for the full context.