[bugfix] fn:function-lookup: capture focus for context-dependent built-ins

exist-core/src/main/java/org/exist/xquery/FunctionFactory.java

@@ -508,6 +508,13 @@ public static FunctionCall wrap(XQueryContext context, Function call) throws XPa
                 newSignature.setArgumentTypes(newParamArray);
 
 		final UserDefinedFunction func = new UserDefinedFunction(context, newSignature);
+		// This wrapper exists to lift a built-in Function into a FunctionCall
+		// so that it can be used as a function item. Built-ins may be
+		// context-dependent (fn:node-name#0, fn:position#0, fn:lang#1, ...),
+		// so let the wrapped body see the caller's focus. See F&O 3.1
+		// section 16.1.1 for the closure-of-context rule that motivates this
+		// for fn:function-lookup and named function references.
+		func.setPropagateContextToBody(true);
 		for (final QName varName: variables) {
 			func.addVariable(varName);
 		}

exist-core/src/main/java/org/exist/xquery/UserDefinedFunction.java

@@ -48,6 +48,18 @@ public class UserDefinedFunction extends Function implements Cloneable {
     private boolean hasBeenReset = false;
     private List<ClosureVariable> closureVariables = null;
 
+    // When true, propagate the caller's focus (context sequence + item) to the
+    // body. Set by FunctionFactory.wrap so that named-function-reference and
+    // fn:function-lookup wrappers around context-dependent built-ins
+    // (fn:node-name#0, fn:string#0, fn:position#0, fn:lang#1, ...) can see a
+    // focus. Plain user-defined functions are not supposed to depend on the
+    // caller's focus, so this flag stays false for them. See F&O 3.1 §16.1.1.
+    private boolean propagateContextToBody = false;
+
+    public void setPropagateContextToBody(final boolean propagateContextToBody) {
+        this.propagateContextToBody = propagateContextToBody;
+    }
+
     public UserDefinedFunction(XQueryContext context, FunctionSignature signature) {
         super(context, signature);
     }
@@ -155,7 +167,11 @@ public Sequence eval(Sequence contextSequence, Item contextItem) throws XPathExc
                             ", got " + currentArguments[j].getItemCount());
                 }
             }
-            result = body.eval(null, null);
+            if (propagateContextToBody) {
+                result = body.eval(contextSequence, contextItem);
+            } else {
+                result = body.eval(null, null);
+            }
             return result;
         } finally {
             // restore the local variable stack

exist-core/src/main/java/org/exist/xquery/functions/fn/FunOnFunctions.java

@@ -94,7 +94,21 @@ public Sequence eval(Sequence[] args, Sequence contextSequence)
                     }
                     throw e;
                 }
-			    return call == null ? Sequence.EMPTY_SEQUENCE : new FunctionReference(this, call);
+			    if (call == null) {
+			        return Sequence.EMPTY_SEQUENCE;
+			    }
+			    final FunctionReference ref = new FunctionReference(this, call);
+			    // F&O 3.1 section 16.1.1: the static and dynamic context of the
+			    // call to fn:function-lookup forms part of the closure of the
+			    // returned function. Capture the focus so that context-dependent
+			    // built-ins (fn:position#0, fn:node-name#0, fn:lang#1, ...) run
+			    // against the focus that was in scope at the lookup site.
+			    final org.exist.xquery.value.Item capturedItem =
+			            (contextSequence != null && !contextSequence.isEmpty())
+			                    ? contextSequence.itemAt(0)
+			                    : null;
+			    ref.setCapturedContext(contextSequence, capturedItem);
+			    return ref;
 			} else if (isCalledAs("function-name")) {
 				final FunctionReference ref = (FunctionReference) args[0].itemAt(0);
 				final QName qname = ref.getSignature().getName();

exist-core/src/main/java/org/exist/xquery/value/FunctionReference.java

@@ -43,6 +43,15 @@ public class FunctionReference extends AtomicValue implements AutoCloseable {
 
     protected final FunctionCall functionCall;
 
+    // Focus captured at the time of fn:function-lookup. When non-null, this
+    // focus is substituted for the function body's evaluation, while the
+    // function's argument expressions are still evaluated in the outer focus.
+    // See F&O 3.1 section 16.1.1 (fn:function-lookup), which states that the
+    // implementation of a returned context-dependent built-in is associated
+    // with the dynamic context of the call to fn:function-lookup.
+    private Sequence capturedContextSequence;
+    private Item capturedContextItem;
+
     public FunctionReference(final FunctionCall functionCall) {
         this(null, functionCall);
     }
@@ -52,6 +61,15 @@ public FunctionReference(final Expression expression, final FunctionCall functio
         this.functionCall = functionCall;
     }
 
+    public void setCapturedContext(final Sequence contextSequence, final Item contextItem) {
+        this.capturedContextSequence = contextSequence;
+        this.capturedContextItem = contextItem;
+    }
+
+    private boolean hasCapturedContext() {
+        return capturedContextSequence != null || capturedContextItem != null;
+    }
+
     public FunctionCall getCall() {
         return functionCall;
     }
@@ -110,7 +128,7 @@ public void analyze(AnalyzeContextInfo contextInfo) throws XPathException {
      * @throws XPathException in case of dynamic error
      */
     public Sequence eval(Sequence contextSequence) throws XPathException {
-        return functionCall.eval(contextSequence, null);
+        return eval(contextSequence, null);
     }
 
     /**
@@ -122,6 +140,18 @@ public Sequence eval(Sequence contextSequence) throws XPathException {
      * @throws XPathException in case of dynamic error
      */
     public Sequence eval(final Sequence contextSequence, final Item contextItem) throws XPathException {
+        if (hasCapturedContext()) {
+            // Per F&O 3.1 section 16.1.1, when fn:function-lookup returns a
+            // context-dependent built-in, the function body must see the focus
+            // captured at lookup time. Argument expressions, however, still
+            // evaluate against the outer focus of the dynamic call site.
+            final int n = functionCall.getArgumentCount();
+            final Sequence[] seq = new Sequence[n];
+            for (int i = 0; i < n; i++) {
+                seq[i] = functionCall.getArgument(i).eval(contextSequence, contextItem);
+            }
+            return functionCall.evalFunction(capturedContextSequence, capturedContextItem, seq);
+        }
         return functionCall.eval(contextSequence, contextItem);
     }
 
@@ -135,6 +165,9 @@ public Sequence eval(final Sequence contextSequence, final Item contextItem) thr
      * @throws XPathException in case of dynamic error
      */
     public Sequence evalFunction(Sequence contextSequence, Item contextItem, Sequence[] seq) throws XPathException {
+        if (hasCapturedContext()) {
+            return functionCall.evalFunction(capturedContextSequence, capturedContextItem, seq);
+        }
         return functionCall.evalFunction(contextSequence, contextItem, seq);
     }
 

exist-core/src/test/xquery/xquery3/higher-order.xml

@@ -749,6 +749,63 @@ return
     $f()]]></code>
         <expected>1 2 3 4 5 6 7 8 9 10</expected>
     </test>
+    <test output="text">
+        <task>fn:function-lookup captures focus: fn:node-name#0</task>
+        <code><![CDATA[xquery version "3.0";
+let $doc := document { <root/> }
+return
+    $doc/root/function-lookup(xs:QName('fn:node-name'), 0)()]]></code>
+        <expected>root</expected>
+    </test>
+    <test output="text">
+        <task>fn:function-lookup captures focus: xqts-002 shape</task>
+        <code><![CDATA[xquery version "3.0";
+let $doc := document { <root/> }
+return
+    ($doc/root)/function-lookup(xs:QName('fn:node-name'), 0)()]]></code>
+        <expected>root</expected>
+    </test>
+    <test output="text">
+        <task>fn:function-lookup captures focus: fn:string#0</task>
+        <code><![CDATA[xquery version "3.0";
+let $doc := document { <root><child>hello</child></root> }
+return
+    $doc/root/child/function-lookup(xs:QName('fn:string'), 0)()]]></code>
+        <expected>hello</expected>
+    </test>
+    <test output="text">
+        <task>fn:function-lookup captures focus: fn:lang#1</task>
+        <code><![CDATA[xquery version "3.0";
+let $doc := document { <root xml:lang="en"/> }
+return
+    $doc/root/function-lookup(xs:QName('fn:lang'), 1)('en')]]></code>
+        <expected>true</expected>
+    </test>
+    <test output="text">
+        <task>fn:function-lookup captures focus: fn:has-children#0</task>
+        <code><![CDATA[xquery version "3.0";
+let $doc := document { <root><child/></root> }
+return
+    $doc/function-lookup(xs:QName('fn:has-children'), 0)()]]></code>
+        <expected>true</expected>
+    </test>
+    <test output="text">
+        <task>fn:function-lookup: 1-arg fn:id captures focus, returns empty when no match</task>
+        <code><![CDATA[xquery version "3.0";
+let $doc := document { <root/> }
+return
+    count($doc/function-lookup(xs:QName('fn:id'), 1)('nope'))]]></code>
+        <expected>0</expected>
+    </test>
+    <test output="text">
+        <task>fn:function-lookup: named function reference still has no captured focus</task>
+        <code><![CDATA[xquery version "3.0";
+declare namespace ex="http://exist-db.org/xquery/ex";
+declare function ex:add($a, $b) { $a + $b };
+let $f := function-lookup(xs:QName('ex:add'), 2)
+return $f(2, 3)]]></code>
+        <expected>5</expected>
+    </test>
     <test output="text">
         <task>Closure test: redefined variable</task>
         <code><![CDATA[xquery version "3.0";