[XPath] Optimize XPath evaluation, now all QT3 tests can be run in reasonable time.

16246 72.2% successes
    0  0.0% skipped
 4007 17.8% failures
 2261 10.0% errors

Author: renggli

bin/xpath_qt3tests.dart

@@ -15,17 +15,14 @@ import 'package:xml/src/xpath/types/string.dart';
 import 'package:xml/xml.dart';
 import 'package:xml/xpath.dart';
 
+/// URL of the official XPath and XQpery W3C test-suite.
 const githubRepository = 'https://github.com/w3c/qt3tests.git';
+
+/// Path to the local catalog file.
 final catalogFile = File('.qt3tests/catalog.xml').absolute;
 
-// These tests are skipped because they are extremely slow.
-const skippedTests = <String>{
-  'cbcl-subsequence-010',
-  'cbcl-subsequence-011',
-  'cbcl-subsequence-012',
-  'cbcl-subsequence-013',
-  'cbcl-subsequence-014',
-};
+/// Test names that are skipped.
+const skippedTests = <String>{};
 
 void main() {
   downloadAndUpdateTestData();
@@ -156,20 +153,27 @@ class TestCase {
       result.skipped++;
       return;
     }
+    final stopwatch = Stopwatch()..start();
     try {
       _test();
-      stdout.writeln(': OK');
+      stopwatch.stop();
+      stdout.writeln(': OK ${formatStopwatch(stopwatch)}');
       result.successes++;
     } on TestFailure catch (error) {
-      stdout.writeln(': FAILURE - ${error.message}');
+      stopwatch.stop();
+      stdout.writeln(
+        ': FAILURE ${formatStopwatch(stopwatch)} - ${formatMessage(error.message)}',
+      );
       result.failures++;
     } catch (error) {
       final message = error is StateError
           ? error.message
           : error is UnsupportedError
-          ? error.message
+          ? (error.message ?? 'Unsupported')
           : error.toString();
-      stdout.writeln(': ERROR - $message');
+      stdout.writeln(
+        ': ERROR ${formatStopwatch(stopwatch)} - ${formatMessage(message)}',
+      );
       result.errors++;
     }
   }
@@ -412,3 +416,13 @@ String formatSequence(XPathSequence sequence) =>
         return item.toString();
       }
     }).join(', ')})';
+
+/// Helper to format a stopwatch duration.
+String formatStopwatch(Stopwatch stopwatch) =>
+    '[${(stopwatch.elapsed.inMicroseconds / 1000).toStringAsFixed(3)}ms]';
+
+/// Helper to format a error message.
+String formatMessage(String message) {
+  final normalize = message.trim().replaceAll(RegExp(r'\s+'), ' ');
+  return normalize.length > 80 ? '${normalize.substring(0, 75)}...' : normalize;
+}

lib/src/xpath/expressions/path.dart

@@ -1,4 +1,7 @@
+import 'package:collection/collection.dart';
+
 import '../../xml/extensions/comparison.dart';
+import '../../xml/extensions/descendants.dart';
 import '../../xml/extensions/parent.dart';
 import '../../xml/nodes/node.dart';
 import '../evaluation/context.dart';
@@ -194,14 +197,34 @@ class PathExpression implements XPathExpression {
         }
         nodes = innerNodes;
       }
-      final result = nodes.toList();
-      result.sort((a, b) {
-        if (a is XmlNode && b is XmlNode) {
-          return a.compareNodePosition(b);
-        }
-        return 0;
-      });
-      return XPathSequence(result);
+      return XPathSequence(_sortAndDeduplicate(nodes, contextNode.root));
+    }
+  }
+
+  static List<Object> _sortAndDeduplicate(Iterable<Object> iter, XmlNode root) {
+    final nodes = <XmlNode>{};
+    final others = <Object>{};
+    for (final item in iter) {
+      if (item is XmlNode) {
+        nodes.add(item);
+      } else {
+        others.add(item);
+      }
+    }
+    final result = <Object>[];
+    if (nodes.length <= 25) {
+      result.addAll(nodes.sorted((a, b) => a.compareNodePosition(b)));
+    } else {
+      if (nodes.remove(root)) result.add(root);
+      for (final node in root.descendants) {
+        if (nodes.isEmpty) break;
+        if (nodes.remove(node)) result.add(node);
+      }
+      if (nodes.isNotEmpty) {
+        result.addAll(nodes.sorted((a, b) => a.compareNodePosition(b)));
+      }
     }
+    result.addAll(others);
+    return result;
   }
 }

lib/src/xpath/functions/sequence.dart

@@ -1,5 +1,3 @@
-import 'package:collection/collection.dart';
-
 import '../../../xml.dart';
 import '../definitions/cardinality.dart';
 import '../definitions/function.dart';
@@ -244,34 +242,68 @@ const fnSubsequence = XPathFunctionDefinition(
       type: xsAny,
       cardinality: XPathCardinality.zeroOrMore,
     ),
-    XPathArgumentDefinition(name: 'startingLoc', type: xsInteger),
+    XPathArgumentDefinition(name: 'startingLoc', type: xsDouble),
   ],
-  optionalArguments: [XPathArgumentDefinition(name: 'length', type: xsInteger)],
+  optionalArguments: [XPathArgumentDefinition(name: 'length', type: xsDouble)],
   function: _fnSubsequence,
 );
 
 XPathSequence _fnSubsequence(
   XPathContext context,
   XPathSequence sourceSeq,
-  int startingLoc, [
-  int? length,
+  double startingLoc, [
+  double? length,
 ]) {
-  final start = startingLoc;
-  final len = length;
-  if (len != null) {
-    final end = start + len;
-    return XPathSequence(
-      sourceSeq.toList().whereIndexed((int index, Object item) {
-        final pos = index + 1;
-        return pos >= start && pos < end;
-      }),
-    );
+  if (startingLoc.isNaN || (length != null && length.isNaN)) {
+    return XPathSequence.empty;
   }
-  return XPathSequence(
-    sourceSeq.toList().whereIndexed(
-      (int index, Object item) => index + 1 >= start,
-    ),
-  );
+
+  final startRound = startingLoc.isInfinite
+      ? startingLoc
+      : startingLoc.roundToDouble();
+
+  final lengthRound = length == null
+      ? null
+      : (length.isInfinite ? length : length.roundToDouble());
+
+  final endRound = lengthRound != null
+      ? startRound + lengthRound
+      : double.infinity;
+
+  if (endRound.isNaN ||
+      endRound <= 1.0 ||
+      (startRound.isInfinite && startRound > 0)) {
+    return XPathSequence.empty;
+  }
+
+  var skipCount = 0;
+  if (startRound > 1.0) {
+    if (startRound > 9007199254740992.0) {
+      return XPathSequence.empty;
+    }
+    skipCount = (startRound - 1.0).toInt();
+  }
+
+  int? takeCount;
+  if (endRound != double.infinity) {
+    if (endRound > 9007199254740992.0) {
+      takeCount = null;
+    } else {
+      final take = (endRound - 1.0).toInt() - skipCount;
+      if (take <= 0) return XPathSequence.empty;
+      takeCount = take;
+    }
+  }
+
+  Iterable<Object> iter = sourceSeq;
+  if (skipCount > 0) {
+    iter = iter.skip(skipCount);
+  }
+  if (takeCount != null) {
+    iter = iter.take(takeCount);
+  }
+
+  return XPathSequence(iter);
 }
 
 /// https://www.w3.org/TR/xpath-functions-31/#func-unordered