Fix XPath conformance suite failures

Author: frankarensmeier

xee-interpreter/src/context/static_context.rs

@@ -1,3 +1,4 @@
+use ahash::HashSet;
 use std::cell::RefCell;
 use std::fmt::Debug;
 use std::rc::Rc;
@@ -28,14 +29,20 @@ static DEFAULT_COLLATION: LazyLock<IriAbsoluteString> = LazyLock::new(|| {
 pub struct StaticContext {
     parser_context: XPathParserContext,
     functions: &'static function::StaticFunctions,
+    disabled_functions: HashSet<xot::xmlname::OwnedName>,
     // TODO: try to make collations static
     collations: RefCell<Collations>,
     static_base_uri: Option<IriAbsoluteString>,
 }
 
 impl Default for StaticContext {
     fn default() -> Self {
-        Self::new(Namespaces::default(), VariableNames::default(), None)
+        Self::new(
+            Namespaces::default(),
+            VariableNames::default(),
+            HashSet::default(),
+            None,
+        )
     }
 }
 
@@ -44,6 +51,7 @@ impl From<XPathParserContext> for StaticContext {
         Self {
             parser_context,
             functions: &STATIC_FUNCTIONS,
+            disabled_functions: HashSet::default(),
             collations: RefCell::new(Collations::new()),
             static_base_uri: None,
         }
@@ -54,18 +62,25 @@ impl StaticContext {
     pub(crate) fn new(
         namespaces: Namespaces,
         variable_names: VariableNames,
+        disabled_functions: HashSet<xot::xmlname::OwnedName>,
         static_base_uri: Option<IriAbsoluteString>,
     ) -> Self {
         Self {
             parser_context: XPathParserContext::new(namespaces, variable_names),
             functions: &STATIC_FUNCTIONS,
+            disabled_functions,
             collations: RefCell::new(Collations::new()),
             static_base_uri,
         }
     }
 
     pub fn from_namespaces(namespaces: Namespaces) -> Self {
-        Self::new(namespaces, VariableNames::default(), None)
+        Self::new(
+            namespaces,
+            VariableNames::default(),
+            HashSet::default(),
+            None,
+        )
     }
 
     pub fn namespaces(&self) -> &Namespaces {
@@ -137,6 +152,9 @@ impl StaticContext {
         name: &xot::xmlname::OwnedName,
         arity: u8,
     ) -> Option<function::StaticFunctionId> {
+        if self.disabled_functions.contains(name) {
+            return None;
+        }
         self.functions.get_by_name(name, arity)
     }
 

xee-interpreter/src/context/static_context_builder.rs

@@ -1,4 +1,4 @@
-use ahash::HashMap;
+use ahash::{HashMap, HashSet};
 use iri_string::types::IriAbsoluteString;
 use xee_name::Namespaces;
 use xot::xmlname::OwnedName;
@@ -9,6 +9,7 @@ use crate::context;
 pub struct StaticContextBuilder<'a> {
     variable_names: Vec<OwnedName>,
     namespaces: HashMap<&'a str, &'a str>,
+    disabled_functions: HashSet<OwnedName>,
     default_element_namespace: &'a str,
     default_function_namespace: &'a str,
     static_base_uri: Option<IriAbsoluteString>,
@@ -75,6 +76,12 @@ impl<'a> StaticContextBuilder<'a> {
         self
     }
 
+    /// Disable a function name in this static context.
+    pub fn disable_function(&mut self, name: OwnedName) -> &mut Self {
+        self.disabled_functions.insert(name);
+        self
+    }
+
     /// Build the static context.
     ///
     /// This will always include the default known namespaces for
@@ -96,7 +103,12 @@ impl<'a> StaticContextBuilder<'a> {
             default_function_namespace.to_string(),
         );
         let variable_names = self.variable_names.clone().into_iter().collect();
-        context::StaticContext::new(namespaces, variable_names, self.static_base_uri.clone())
+        context::StaticContext::new(
+            namespaces,
+            variable_names,
+            self.disabled_functions.clone(),
+            self.static_base_uri.clone(),
+        )
     }
 }
 

xee-testrunner/src/testcase/assert.rs

@@ -1131,10 +1131,18 @@ fn run_xpath_with_result(
     let q = queries.sequence_with_context(expr, static_context)?;
 
     let variables = AHashMap::from([(name, sequence.clone())]);
-    let context_item = sequence.normalize(" ", documents.xot_mut())?;
+    let context_item = match sequence.normalize(" ", documents.xot_mut()) {
+        Ok(context_item) => Some(context_item.into()),
+        // Function items cannot become the implicit context item for the
+        // assertion query, but $result should still be available.
+        Err(error::ErrorValue::SENR0001) => None,
+        Err(error) => return Err(error.into()),
+    };
 
     q.execute_build_context(documents, |build| {
-        build.context_item(context_item.into());
+        if let Some(context_item) = context_item {
+            build.context_item(context_item);
+        }
         build.variables(variables);
     })
 }
@@ -1212,6 +1220,17 @@ mod tests {
         assert!(result.effective_boolean_value().unwrap());
     }
 
+    #[test]
+    fn test_run_xpath_with_result_allows_function_item_results_via_result_variable() {
+        let mut documents = Documents::new();
+        let sequence = run_xpath(&"map:entry('foo', 3)".to_string()).unwrap();
+
+        let expr = "$result?foo = 3".to_string();
+        let result = run_xpath_with_result(&expr, &sequence, &mut documents).unwrap();
+
+        assert!(result.effective_boolean_value().unwrap());
+    }
+
     #[test]
     fn test_assert_xml_ignores_outer_fragment_whitespace() {
         let mut xot = Xot::new();

xee-testrunner/src/testcase/xpath.rs

@@ -99,6 +99,11 @@ impl Runnable<XPathLanguage> for XPathTestCase {
             Err(error) => return TestOutcome::EnvironmentError(error.to_string()),
         };
         static_context_builder.namespaces(namespaces);
+        static_context_builder.disable_function(xot::xmlname::OwnedName::new(
+            "document".to_string(),
+            xee_name::Namespaces::FN_NAMESPACE.to_string(),
+            "fn".to_string(),
+        ));
 
         // now construct a query with that static context
         let static_context = static_context_builder.build();