XPath: Flatten the AST to make it more flexible (servo#39800)

The current XPath AST is tightly tied to the parser grammar. To address
issues like servo#39739, we'll want to
do optimization passes on the AST in the future, which requires relaxing
it's structure first.

This PR moves the AST structure into a separate module and flattens it
into a shape where most expressions are variants of the core
`Expression` enum.

This also has the nice side effect of being a net reduction in LoC and
making the AST *significantly* easier to read.

I think the difference between the old and new structure is best
explained by example.
One of our unit tests parses `concat('hello', ' ', 'world')`, and the
current AST looks like this:

```rust
Expr::Path(PathExpr {
    is_absolute: false,
    is_descendant: false,
    steps: vec![StepExpr::Filter(FilterExpr {
        primary: PrimaryExpr::Function(CoreFunction::Concat(vec![
            Expr::Path(PathExpr {
                is_absolute: false,
                is_descendant: false,
                steps: vec![StepExpr::Filter(FilterExpr {
                    primary: PrimaryExpr::Literal(Literal::String(
                        "hello".to_string(),
                    )),
                    predicates: PredicateListExpr { predicates: vec![] },
                })],
            }),
            Expr::Path(PathExpr {
                is_absolute: false,
                is_descendant: false,
                steps: vec![StepExpr::Filter(FilterExpr {
                    primary: PrimaryExpr::Literal(Literal::String(" ".to_string())),
                    predicates: PredicateListExpr { predicates: vec![] },
                })],
            }),
            Expr::Path(PathExpr {
                is_absolute: false,
                is_descendant: false,
                steps: vec![StepExpr::Filter(FilterExpr {
                    primary: PrimaryExpr::Literal(Literal::String(
                        "world".to_string(),
                    )),
                    predicates: PredicateListExpr { predicates: vec![] },
                })],
            }),
        ])),
        predicates: PredicateListExpr { predicates: vec![] },
    })],
}),
```
After this change, the AST looks like this:
```rust
Expression::Function(CoreFunction::Concat(vec![
    Expression::Literal(Literal::String("hello".to_string())),
    Expression::Literal(Literal::String(" ".to_string())),
    Expression::Literal(Literal::String("world".to_string())),
])),
```

Testing:  No behaviour change intended, covered by existing tests.
Part of servo#34527

---------

Signed-off-by: Simon Wülker <[email protected]>

Author: simonwuelker

components/script/dom/xpathexpression.rs

@@ -6,7 +6,7 @@ use std::rc::Rc;
 
 use dom_struct::dom_struct;
 use js::rust::HandleObject;
-use xpath::{Error as XPathError, Expr, evaluate_parsed_xpath};
+use xpath::{Error as XPathError, Expression, evaluate_parsed_xpath};
 
 use crate::dom::bindings::codegen::Bindings::XPathExpressionBinding::XPathExpressionMethods;
 use crate::dom::bindings::codegen::Bindings::XPathNSResolverBinding::XPathNSResolver;
@@ -24,11 +24,11 @@ pub(crate) struct XPathExpression {
     reflector_: Reflector,
     window: Dom<Window>,
     #[no_trace]
-    parsed_expression: Expr,
+    parsed_expression: Expression,
 }
 
 impl XPathExpression {
-    fn new_inherited(window: &Window, parsed_expression: Expr) -> XPathExpression {
+    fn new_inherited(window: &Window, parsed_expression: Expression) -> XPathExpression {
         XPathExpression {
             reflector_: Reflector::new(),
             window: Dom::from_ref(window),
@@ -40,7 +40,7 @@ impl XPathExpression {
         window: &Window,
         proto: Option<HandleObject>,
         can_gc: CanGc,
-        parsed_expression: Expr,
+        parsed_expression: Expression,
     ) -> DomRoot<XPathExpression> {
         reflect_dom_object_with_proto(
             Box::new(XPathExpression::new_inherited(window, parsed_expression)),

components/xpath/src/ast.rs

@@ -0,0 +1,200 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use malloc_size_of_derive::MallocSizeOf;
+
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub enum Expression {
+    Binary(Box<Expression>, BinaryOperator, Box<Expression>),
+    Negate(Box<Expression>),
+    Path(PathExpression),
+    /// <https://www.w3.org/TR/1999/REC-xpath-19991116/#section-Location-Steps>
+    LocationStep(LocationStepExpression),
+    Filter(FilterExpression),
+    Literal(Literal),
+    Variable(QName),
+    ContextItem,
+    /// We only support the built-in core functions.
+    Function(CoreFunction),
+}
+
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub enum BinaryOperator {
+    Or,
+    And,
+    Union,
+    /// `=`
+    Equal,
+    /// `!=`
+    NotEqual,
+    /// `<`
+    LessThan,
+    /// `>`
+    GreaterThan,
+    /// `<=`
+    LessThanOrEqual,
+    /// `>=`
+    GreaterThanOrEqual,
+    /// `+`
+    Add,
+    /// `-`
+    Subtract,
+    /// `*`
+    Multiply,
+    /// `div`
+    Divide,
+    /// `mod`
+    Modulo,
+}
+
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub struct PathExpression {
+    /// Whether this is an absolute (as opposed to a relative) path expression.
+    ///
+    /// Absolute paths always start at the starting node, not the context node.
+    pub(crate) is_absolute: bool,
+    /// Whether this expression starts with `//`. If it does, then an implicit
+    /// `descendant-or-self::node()` step will be added.
+    pub(crate) has_implicit_descendant_or_self_step: bool,
+    pub(crate) steps: Vec<Expression>,
+}
+
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub struct PredicateListExpression {
+    pub(crate) predicates: Vec<Expression>,
+}
+
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub struct FilterExpression {
+    pub(crate) expression: Box<Expression>,
+    pub(crate) predicates: PredicateListExpression,
+}
+
+/// <https://www.w3.org/TR/1999/REC-xpath-19991116/#section-Location-Steps>
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub struct LocationStepExpression {
+    pub(crate) axis: Axis,
+    pub(crate) node_test: NodeTest,
+    pub(crate) predicate_list: PredicateListExpression,
+}
+
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub(crate) enum Axis {
+    Child,
+    Descendant,
+    Attribute,
+    Self_,
+    DescendantOrSelf,
+    FollowingSibling,
+    Following,
+    Namespace,
+    Parent,
+    Ancestor,
+    PrecedingSibling,
+    Preceding,
+    AncestorOrSelf,
+}
+
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub(crate) enum NodeTest {
+    Name(QName),
+    Wildcard,
+    Kind(KindTest),
+}
+
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub struct QName {
+    pub(crate) prefix: Option<String>,
+    pub(crate) local_part: String,
+}
+
+impl std::fmt::Display for QName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.prefix {
+            Some(prefix) => write!(f, "{}:{}", prefix, self.local_part),
+            None => write!(f, "{}", self.local_part),
+        }
+    }
+}
+
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub(crate) enum KindTest {
+    PI(Option<String>),
+    Comment,
+    Text,
+    Node,
+}
+
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub enum Literal {
+    Integer(i64),
+    Decimal(f64),
+    String(String),
+}
+
+/// In the DOM we do not support custom functions, so we can enumerate the usable ones
+#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
+pub enum CoreFunction {
+    // Node Set Functions
+    /// last()
+    Last,
+    /// position()
+    Position,
+    /// count(node-set)
+    Count(Box<Expression>),
+    /// id(object)
+    Id(Box<Expression>),
+    /// local-name(node-set?)
+    LocalName(Option<Box<Expression>>),
+    /// namespace-uri(node-set?)
+    NamespaceUri(Option<Box<Expression>>),
+    /// name(node-set?)
+    Name(Option<Box<Expression>>),
+
+    // String Functions
+    /// string(object?)
+    String(Option<Box<Expression>>),
+    /// concat(string, string, ...)
+    Concat(Vec<Expression>),
+    /// starts-with(string, string)
+    StartsWith(Box<Expression>, Box<Expression>),
+    /// contains(string, string)
+    Contains(Box<Expression>, Box<Expression>),
+    /// substring-before(string, string)
+    SubstringBefore(Box<Expression>, Box<Expression>),
+    /// substring-after(string, string)
+    SubstringAfter(Box<Expression>, Box<Expression>),
+    /// substring(string, number, number?)
+    Substring(Box<Expression>, Box<Expression>, Option<Box<Expression>>),
+    /// string-length(string?)
+    StringLength(Option<Box<Expression>>),
+    /// normalize-space(string?)
+    NormalizeSpace(Option<Box<Expression>>),
+    /// translate(string, string, string)
+    Translate(Box<Expression>, Box<Expression>, Box<Expression>),
+
+    // Number Functions
+    /// number(object?)
+    Number(Option<Box<Expression>>),
+    /// sum(node-set)
+    Sum(Box<Expression>),
+    /// floor(number)
+    Floor(Box<Expression>),
+    /// ceiling(number)
+    Ceiling(Box<Expression>),
+    /// round(number)
+    Round(Box<Expression>),
+
+    // Boolean Functions
+    /// boolean(object)
+    Boolean(Box<Expression>),
+    /// not(boolean)
+    Not(Box<Expression>),
+    /// true()
+    True,
+    /// false()
+    False,
+    /// lang(string)
+    Lang(Box<Expression>),
+}