[XPath] Fix function and namespace handling.

16229 72.1% successes
    5  0.0% skipped
 4010 17.8% failures
 2270 10.1% errors

Author: renggli

.vscode/launch.json

@@ -2,24 +2,39 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "Run all Tests",
+      "name": "Run Unit Tests",
       "type": "dart",
       "request": "launch",
       "program": "test"
     },
+    {
+      "name": "Run QT3 Tests",
+      "type": "dart",
+      "request": "launch",
+      "program": "bin/xpath_qt3tests.dart",
+      "console": "terminal",
+    },
     {
       "name": "Run XML Benchmarks",
       "type": "dart",
       "request": "launch",
       "program": "bin/xml_benchmark.dart",
       "console": "terminal",
+      "enableAsserts": false,
+      "args": [
+        "--no-xml",
+      ],
     },
     {
       "name": "Run XPath Benchmarks",
       "type": "dart",
       "request": "launch",
       "program": "bin/xpath_benchmark.dart",
       "console": "terminal",
+      "enableAsserts": false,
+      "args": [
+        "--no-xml"
+      ],
     },
   ]
 }

bin/xpath_qt3tests.dart

@@ -8,7 +8,6 @@ import 'dart:io';
 
 import 'package:collection/collection.dart';
 import 'package:xml/src/xpath/evaluation/context.dart';
-import 'package:xml/src/xpath/evaluation/functions.dart';
 import 'package:xml/src/xpath/types/boolean.dart';
 import 'package:xml/src/xpath/types/node.dart';
 import 'package:xml/src/xpath/types/number.dart';
@@ -234,14 +233,9 @@ class TestEnvironment {
 
   late final XmlDocument? source = _getSource();
 
-  XPathContext get context {
-    final ctx = XPathContext(
-      source ?? XPathSequence.empty,
-      functions: standardFunctions,
-      variables: _getParams(),
-    );
-    return ctx;
-  }
+  XPathContext get context => XPathContext.canonical(
+    source ?? XPathSequence.empty,
+  ).copy(variables: _getParams());
 
   XmlDocument? _getSource() {
     final file = element
@@ -256,15 +250,13 @@ class TestEnvironment {
 
   Map<String, Object> _getParams() {
     final params = <String, Object>{};
-    final evalContext = XPathContext(
-      source ?? XPathSequence.empty,
-      functions: standardFunctions,
-    );
     for (final param in element.findElements('param')) {
       final name = param.getAttribute('name');
       final select = param.getAttribute('select');
       if (name != null && select != null) {
-        params[name] = evalContext.evaluate(select);
+        params[name] = XPathContext.canonical(
+          source ?? XPathSequence.empty,
+        ).evaluate(select);
       }
     }
     return params;
@@ -316,11 +308,9 @@ void verifyResult(XmlElement element, Object result, XPathContext context) {
   // Execute the different assertion types.
   switch (element.localName) {
     case 'assert':
-      final evaluation = XPathContext(
+      final evaluation = XPathContext.canonical(
         XPathSequence.empty,
-        variables: {'result': result},
-        functions: standardFunctions,
-      ).evaluate(element.innerText);
+      ).copy(variables: {'result': result}).evaluate(element.innerText);
       if (xsBoolean.cast(evaluation) != true) {
         throw TestFailure(
           'Expected true for ${element.innerText} with result=$result, '
@@ -363,19 +353,17 @@ void verifyResult(XmlElement element, Object result, XPathContext context) {
         throw TestFailure('Expected $xml, but got $result');
       }
     case 'assert-type':
-      final evaluation = XPathContext(
-        XPathSequence.empty,
-        variables: {'result': result},
-        functions: standardFunctions,
-      ).evaluate('\$result instance of ${element.innerText}');
+      final evaluation = XPathContext.canonical(XPathSequence.empty)
+          .copy(variables: {'result': result})
+          .evaluate('\$result instance of ${element.innerText}');
       if (xsBoolean.cast(evaluation) != true) {
         throw TestFailure(
           'Expected true for ${element.innerText} with result=$result, '
           'to be of type ${element.innerText}',
         );
       }
     case 'assert-permutation':
-      final expected = XPathContext(
+      final expected = XPathContext.canonical(
         XPathSequence.empty,
       ).evaluate(element.innerText);
       if (const SetEquality<Object>().equals(

lib/src/xml/utils/name.dart

@@ -49,9 +49,7 @@ class XmlName with XmlHasVisitor, XmlHasWriter {
       final index = name.indexOf(XmlToken.namespace);
       if (index > 0) {
         final prefix = name.substring(0, index);
-        if (namespaceUris.containsKey(prefix)) {
-          uri = namespaceUris[prefix];
-        }
+        uri = namespaceUris[prefix];
       }
     }
     // Handle the default namespace.
@@ -102,6 +100,10 @@ class XmlName with XmlHasVisitor, XmlHasWriter {
       ? '${XmlToken.openQualifiedUrl}$namespaceUri${XmlToken.closeQualifiedUrl}$local'
       : qualified;
 
+  /// Returns a new [XmlName] with the given [namespaceUri].
+  XmlName withNamespaceUri(String? namespaceUri) =>
+      XmlName.qualified(qualified, namespaceUri: namespaceUri);
+
   @override
   String toString() => qualified;
 

lib/src/xpath/definitions/function.dart

@@ -1,3 +1,4 @@
+import '../../xml/utils/name.dart';
 import '../evaluation/context.dart';
 import '../exceptions/evaluation_exception.dart';
 import '../types/any.dart';
@@ -11,18 +12,14 @@ export 'package:petitparser/petitparser.dart' show unbounded;
 class XPathFunctionDefinition {
   const XPathFunctionDefinition({
     required this.name,
-    this.aliases = const [],
     this.requiredArguments = const [],
     this.optionalArguments = const [],
     this.variadicArgument,
     required this.function,
   });
 
   /// The name of the function.
-  final String name;
-
-  /// The aliases of the function.
-  final List<String> aliases;
+  final XmlName name;
 
   /// The required argument definitions.
   final List<XPathArgumentDefinition> requiredArguments;
@@ -81,7 +78,7 @@ class XPathFunctionDefinition {
 
   @override
   String toString() =>
-      '$name(${requiredArguments.join(', ')}, '
+      '${name.qualified}(${requiredArguments.join(', ')}, '
       '${optionalArguments.join(', ')}, '
       '${variadicArgument != null ? '...' : ''})';
 }
@@ -114,14 +111,14 @@ class XPathArgumentDefinition {
         final iterable = sequence.iterator;
         if (!iterable.moveNext()) {
           throw XPathEvaluationException(
-            'Function "${definition.name}" expects exactly one value for '
+            'Function "${definition.name.qualified}" expects exactly one value for '
             'argument "$name", but got none.',
           );
         }
         final value = iterable.current;
         if (iterable.moveNext()) {
           throw XPathEvaluationException(
-            'Function "${definition.name}" expects exactly one value for '
+            'Function "${definition.name.qualified}" expects exactly one value for '
             'argument "$name", but got more than one.',
           );
         }
@@ -134,7 +131,7 @@ class XPathArgumentDefinition {
         final value = iterable.current;
         if (iterable.moveNext()) {
           throw XPathEvaluationException(
-            'Function "${definition.name}" expects zero or one value for '
+            'Function "${definition.name.qualified}" expects zero or one value for '
             'argument "$name", but got more than one.',
           );
         }
@@ -143,7 +140,7 @@ class XPathArgumentDefinition {
         final iterable = sequence.iterator;
         if (!iterable.moveNext()) {
           throw XPathEvaluationException(
-            'Function "${definition.name}" expects one or more values for '
+            'Function "${definition.name.qualified}" expects one or more values for '
             'argument "$name", but got none.',
           );
         }

lib/src/xpath/evaluation/context.dart

@@ -1,23 +1,38 @@
 import '../../xml/nodes/node.dart';
+import '../../xml/utils/name.dart';
 import '../exceptions/evaluation_exception.dart';
 import '../grammars/parser.dart';
 import '../types/function.dart';
 import '../types/sequence.dart';
+import 'functions.dart';
 import 'namespaces.dart';
 
 /// Runtime execution context to evaluate XPath expressions.
 class XPathContext {
-  XPathContext(
+  /// Creates an empty XPath context.
+  XPathContext.empty(
     this.item, {
     this.position = 1,
     this.last = 1,
     this.variables = const {},
     this.functions = const {},
+    this.namespaceUri,
+    this.namespaceUris = const {},
     this.documents = const {},
-    this.namespaces = const {},
     this.onTraceCallback,
   });
 
+  /// Creates a canonical XPath context on [item].
+  XPathContext.canonical(this.item)
+    : position = 1,
+      last = 1,
+      variables = const {},
+      functions = standardFunctions,
+      namespaceUri = xpathFnNamespace,
+      namespaceUris = xpathNamespaceUris,
+      documents = const {},
+      onTraceCallback = null;
+
   /// Mutable context node.
   Object item;
 
@@ -30,15 +45,18 @@ class XPathContext {
   /// User-defined variables.
   final Map<String, Object> variables;
 
-  /// User-defined functions.
-  final Map<String, XPathFunction> functions;
+  /// Available function definitions.
+  final Map<XmlName, XPathFunction> functions;
+
+  /// Default namespace URI for function lookups.
+  final String? namespaceUri;
+
+  /// Namespace mapping from prefix to URIs.
+  final Map<String, String> namespaceUris;
 
   /// Available documents.
   final Map<String, XmlNode> documents;
 
-  /// Available namespaces.
-  final Map<String, String> namespaces;
-
   /// Callback to trace evaluation.
   final XPathTraceCallback? onTraceCallback;
 
@@ -50,27 +68,38 @@ class XPathContext {
   }
 
   /// Looks up a XPath function with the given [name].
-  XPathFunction getFunction(String name) {
-    final function = functions[name] ?? functions[_resolveEqName(name)];
+  XPathFunction getFunction(XmlName name) {
+    final function = functions[name];
     if (function != null) return function;
     throw XPathEvaluationException('Unknown function: $name');
   }
 
-  /// Creates a copy of the current context.
+  /// Looks up a XPath function with the given [name].
+  XPathFunction getFunctionByString(String name) => getFunction(
+    XmlName.parse(
+      name,
+      namespaceUri: namespaceUri,
+      namespaceUris: namespaceUris,
+    ),
+  );
+
+  /// Creates a copy of this context.
   XPathContext copy({
     Map<String, Object>? variables,
-    Map<String, XPathFunction>? functions,
+    Map<XmlName, XPathFunction>? functions,
+    String? namespaceUri,
+    Map<String, String>? namespaceUris,
     Map<String, XmlNode>? documents,
-    Map<String, String>? namespaces,
     XPathTraceCallback? onTraceCallback,
-  }) => XPathContext(
+  }) => XPathContext.empty(
     item,
     position: position,
     last: last,
-    variables: variables ?? this.variables,
-    functions: functions ?? this.functions,
-    documents: documents ?? this.documents,
-    namespaces: namespaces ?? this.namespaces,
+    variables: _extend(this.variables, variables),
+    functions: _extend(this.functions, functions),
+    documents: _extend(this.documents, documents),
+    namespaceUri: namespaceUri ?? this.namespaceUri,
+    namespaceUris: _extend(this.namespaceUris, namespaceUris),
     onTraceCallback: onTraceCallback ?? this.onTraceCallback,
   );
 
@@ -82,13 +111,8 @@ class XPathContext {
 /// Function type for tracing evaluation.
 typedef XPathTraceCallback = void Function(XPathSequence value, String? label);
 
-/// Resolves a `Q{uri}local-name` EQName to its `prefix:local-name` form.
-String? _resolveEqName(String name) {
-  if (!name.startsWith('Q{')) return null;
-  final end = name.indexOf('}');
-  if (end < 0) return null;
-  final uri = name.substring(2, end);
-  final localName = name.substring(end + 1);
-  final prefix = standardNamespaces[uri];
-  return prefix != null ? '$prefix:$localName' : null;
+Map<K, V> _extend<K, V>(Map<K, V> original, Map<K, V>? other) {
+  if (other == null || other.isEmpty) return original;
+  if (original.isEmpty) return other;
+  return {...original, ...other};
 }

lib/src/xpath/evaluation/functions.dart

@@ -1,3 +1,4 @@
+import '../../xml/utils/name.dart';
 import '../definitions/function.dart';
 import '../functions/accessor.dart' as accessor;
 import '../functions/array.dart' as array;
@@ -18,14 +19,14 @@ import '../functions/sequence.dart' as sequence;
 import '../functions/string.dart' as string;
 import '../functions/uri.dart' as uri;
 import '../types/function.dart';
+import 'namespaces.dart';
 
 /// The standard functions.
-final Map<String, XPathFunction> standardFunctions = {
-  for (final functionDefinition in standardFunctionDefinitions) ...{
-    functionDefinition.name: functionDefinition.call,
-    for (var alias in functionDefinition.aliases)
-      alias: functionDefinition.call,
-  },
+final Map<XmlName, XPathFunction> standardFunctions = {
+  for (final definition in standardFunctionDefinitions)
+    definition.name.withNamespaceUri(
+      xpathNamespaceUris[definition.name.prefix],
+    ): definition.call,
 };
 
 /// Internal list of standard function definitions.

lib/src/xpath/evaluation/namespaces.dart

@@ -11,21 +11,11 @@ const xpathXsNamespace = 'http://www.w3.org/2001/XMLSchema';
 const xpathLocalNamespace = 'http://www.w3.org/2005/xquery-local-functions';
 
 /// Standard XPath namespace prefixes.
-const standardPrefixes = {
+const xpathNamespaceUris = {
   'fn': xpathFnNamespace,
   'math': xpathMathNamespace,
   'map': xpathMapNamespace,
   'array': xpathArrayNamespace,
   'xs': xpathXsNamespace,
   'local': xpathLocalNamespace,
 };
-
-/// Standard XPath namespaces.
-const standardNamespaces = {
-  xpathFnNamespace: 'fn',
-  xpathMathNamespace: 'math',
-  xpathMapNamespace: 'map',
-  xpathArrayNamespace: 'array',
-  xpathXsNamespace: 'xs',
-  xpathLocalNamespace: 'local',
-};