This is a TODO file for XSL-T 2.0 support.

- LHF:

    * Warning bug, last parameter is always whined about.

    * Box in comment/PI/text/ws(?) handling -- pending Matthias

    * type036 -- namespace on top element isn't copied

    * XTDE0865

    * Attend XSLTTokenizer::isXSLT()

    * Remove redundant set() calls in setFocusHelper().

- Missing features:

    General                                     Priority

    ---------------------

    * 1.0 QXmlQuery::evaluateTo(QIODevice *)    P1 DONE

    * 1.0 Test suite integration                P1 DONE

    * 1.0 xsl:key                               P1

    * 1.0 fn:key()                              P1

    * 1.0 2.0 Compatibility mode                P1

    * 1.0 Regular parameters in templates       P1

    * 1.0 xsl:include                           P1

    * 1.0 xsl:copy-of                           P1

    * 1.0 xsl:copy                              P1

    * 1.0 xsl:import                            P1

    * 1.0 fn:format-number                      P1

    * 1.0 xsl:message                           P2

    * 1.0 fn:current()                          P1 DONE

    * 2.0 fn:type-available()                   P3 DONE

    * 2.0 xsl:use-when                          P3

    * 2.0 fn:unparsed-entity-uri()              P3

    * 2.0 fn:unparsed-entity-public-id()        P3

    * 2.0 Tunnel Parameters                     P3

    * 2.0 xsl:attribute-set                     P3

    * 1.0 xsl:decimal-format                    P2

    * 1.0 xmlpatterns: initial template         P1 DONE

    * 1.0 xsl:number                            P1

    * 1.0 Complete handling of xsl:sort         P2

    * 2.0 Grouping

        - fn:current-group()

        - fn:grouping-key()

        - xsl:for-each-group()

    * 2.0 Regexp

        - xsl:analyze-string

        - xsl:matching-substring

        - xsl:non-matching-substring

        - fn:regex-group()

    * 2.0 Date & Time formatting

        - fn:format-dateTime()

        - fn:format-date()

        - fn:format-time()

    Serialization & Output:

    ----------------------

    * 1.0 xsl:output

    --- Tie together serialization. Should we add

        QXmlQuery::evaluateTo(QIODevice 1.0 const) ?

    * 2.0 xsl:character-maps

    * 2.0 xsl:character-map

    * 2.0 xsl:result-document

    --- Should the "default output" be handle with xsl:result-document? Would

        depend on compilation.

Optimizations:

    * Remove adjacent text node constructors

    * Remove string-join when first arg's static cardinality is not more than one

    * Remove string-join when the second arg is statically known to be the empty string.

    * Remove string-join when the second arg is a single space and the parent is a text node ctor.

    * Rewrite to operand if operands are one. What about type conversions?

    * Replace lookups with xml:id with calls on id().

    * Recognize that a/(b, c) is equal to a/(b | c). The later does selection and node sorting in one step.

    * Remove LetClause which has empty sequence as return clause, or no variable dependencies at all.

    * Do a mega test for rewriting /patterns/:

                    "node() | element()" => element()

                    "comment() | node()" => comment()

      and so forth. This sometimes happens in poorly written patterns. How does

      this rewrite affect priority calculation?

Tests:

    * xml:id

        - Come on, the stuff needs to be reorganized xml:id.

        - Read in xml:id document with whitespace in attrs, write the doc out. Attrs should be normalized.

        - Do lookups of IDs with xml:id attrs containing whitespace.

    * current()

        - Use current() inside each instruction

        - In a template pattern

        - Several invocations: current()/current()/current()

    * Diagnosticsts:

        - See http://www.w3.org/Bugs/Public/show_bug.cgi?id=5643 . Comments

          should be taken into account when comparing. This suggests that we

          don't have any test which produces a document with XML comments.

    * element-available()

        - Review the tests.

        - Try using declarations in XSL-T, should return false

        - Use xsl:variable(both instr and decl)

        - invoke with all the XSL-T instructions.

        - Should return false for when, otherwise, matching-substring, non-matching-substring, etc?

        - Supply the namespace in the name via the default namespace, no prefix.

    * unparsed-text()

        - Load an empty file

        - Use a fragment in the URI

        - Use an invalid URI

        - Use device bindings and a QRC to ensure that we're not using a generic

          network manager.

        - Duplicate all the network tests. Same as for doc()

    * unparsed-text-available()

        - Same as for unparsed-text()

    * Sequence constructor that contains only:

        - XML comment

        - whitespace text node

        - processing instruction

        - a mix of the three

    * xsl:function

        - Ensure that it's not it's not in scope for use-when.

        - xsl:function/xsl:param: use processing instructions, whitespace and comments as child: should be stripped

        - Use <xsl:function/> : @name missing.

        - Don't strip ws, and have ws between two xsl:param, and between xsl:function and xsl:param.

        - Use xsl:function with no body.

        - use xsl:param/@tunnel = no

        - use xsl:param/@tunnel = yes

        - use an invalid value for xsl:param/@tunnel = yes

        - Have a non-WS text node in xsl:function/xsl:param/

        - Have a WS text node in xsl:function/xsl:param/

        - Have a WS text node in xsl:function/xsl:param/ while preserving WS.

        - use a comment as child of xsl:param

        - use a PI as child of xsl:param

        - XTSE0770 with import precedence and all that.

        - have two identical function in the stylesheet. The last has override=no. Should still report XTSE0770.

        - have @override with invalid value.

        - have whitespace inside xsl:param with different strip modes.

        - Have @select => error

        - Have body => error

        - call current() inside body. XPDY0002?

    * Does xml:base/StaticBaseURI and StaticCompatiblityStore prevent proper

          type checking due to expectedOperandTypes() returns item()*?

    * xsl:template/xsl:param

        - Have @required=yes, and have @select => error

        - Have @required=yes, and have body => error

        - Have a variable reference in a template after another, which has

          param, to ensure they aren't in scope.

    * xsl:template/@match

        - Have a pattern with unions, and have a body which relies on its

          static type.

    * @version:

        Have @version on *all* attributes.

    * xsl:call-template

        - Have a variable reference just after a xsl:call-template which has

          with-param, to ensure they aren't in scope.

        - Have an xsl:with-param which isn't used in the template. Error?

        - Have an xsl:with-param that has a type error.

        - an xsl:with-param is not in scope for the next one. Test this => error.

        - Have a call:template, whose with-param computes its value by calling

          another template, while using an with-param too.

    * XQuery:

        - DONE Ensure namespace {expr} {expr} is flagged as invalid

        - Use all XSL-T functions: error. Or we do that already?

        - Ensure order by collation 1 + 1 is an error

        - Ensure order by collation {1 + 1} is an error

    * document()

        - Basic node deduplication, no test exists for that.

    * xsl:perform-sort

        - Have no xsl:sort. Error. Must be at least one.

        - have xsl:sort with invalid value.

        - sort atomic values.

        - Trigger "The stable attribute is permitted only on the first xsl:sort  element within a sort key specification"

        - have xsl:sort with no select and no seq ctor.

        - trigger the delegated queueing. All instructions inside.. xsl:sort?

        - have multiple sort statements, with the last being <xsl:sort/> only.

        - have WS between xsl:sort that is not ignorable.

        - Use a variable reference whose name is equal to our synthetic name. This should be XPST0008, but probably isn't.

        - Have an invalid value in xsl:sort/order. Use space

        - have xsl:sort return numbers, but data-type specify string.

        - have an AVT in xsl:sort/@lang

        - have an AVT in xsl:sort/@case-order

        - have an AVT in xsl:sort/@data-type

        - have an AVT in xsl:sort/@stable

        - Have mixed result, and hence incorrectly trigger  XPTY0018 which the code currently raise.

        - Depend on the context position inside xsl:sort, when being child of

          perform-sort. Currently we create singleton focuses(I think), while

          we want the focus to be over the whole input sequence, not on indivual items.

        - Have <xsl:perform-sort select="valid-expr"/>: xsl:sort is missing

        - Use current() in the xsl:sort and the body, to ensure the right scope is picked up

    * xsl:copy-of

        - Have a text node. It's not allowed.

        - Have PIs, comments, and ignorable whitespace as children. Sigh.

    * xsl:namespace

        - Use xsl:fallback.

        - Use xsl:namespace inside xsl:variable and introspec the result in various

          ways. This is a big area, we don't have namespace nodes in XQuery. Yes, calling evaluateSingleton() will probably crash.

        - Use no select and no body, error: XTSE0910

        - Have name expression evaluate to the empty sequence.

    * Sequence ctor that:

        - Has invalid element in XSL namespace. E.g, xsl:foo

    * xsl:import

        - Have element as child as xsl:import: disallowed.

        - Have text as child as xsl:import: disallowed.

        - Have PIs and comments as child as xsl:import: allowed.

    * xsl:include

        - Have element as child as xsl:include: disallowed.

        - Have text as child as xsl:include: disallowed.

        - Have PIs and comments as child as xsl:include: allowed.

    * xsl:strip-space

        - Have PIs, comments, whitespace as child.

    * xsl:element

        - Extract EBV from result.

        - Use space in validation element.

    * xsl:perform-sort

        - Have PIs and comments in between xsl:sort elements.

    * xml:space

        - We never pop our stack. Fix the bug, and ensure we have tests for it.

    * fn:unparsed-entity-uri

        - Check type of return value

        - Do basic unparsed-entity-uri("does-not-exist")

    * fn:unparsed-entity-public-id

        - Do basic unparsed-entity-uri("does-not-exist"), two permutations, check the spec

    * xsl:element

        - Use disallowed attribute: select

        - use unknown type in @type

        - Use @namespace, but be not in the lexical space of xs:anyURI

        - use disallowed enumeration in @validation

        - have a name expression that evaluates to a xs:QName value as opposed to a string.

        - have a name expression that evaluates to a xs:QName value as opposed to a string. but

          also have the namespace attribute

    * xsl:attribute

        - Use disallowed attribute: match

        - use unknown type in @type

        - Use @namespace, but be not in the lexical space of xs:anyURI

        - use disallowed enumeration in @validation

        - have a name expression that evaluates to a xs:QName value as opposed to a string.

        - have a name expression that evaluates to a xs:QName value as opposed to a string. but

          also have the namespace attribute

    * xsl:template

        - Use the union keyword, it's forbidden, only "|" is allowed

        - Use an expression other than Literal and VarRef in KeyValue[8]

        - use a function other than key().

        - have a declaration that only can apperar as a child of xsl:stylesheet.

        - Have an element in the XSL-T namespace, but which is invalid, e.g "bar"

        - Use an axis other than child or attribute in pattern.

        - Have a template that no no match and no name attribute.,  XTSE0500

        - use child::document-node() in pattern

        - use @foo/child in pattern

        - apply templates to parentless attributes.

        - Have 3e3 in @priority

        - Have a @match with more than two alternatives, e.g "a | b | c", and have them all actually matching.

        - Use an XML name in the mode so we trigger

          NCNameConstructor::validateTargetName()

        - A template which only has a non-WS text node.

        - A template with param, followed by text node.

    * Simplified stylesheet

        - Use @version attribute only on doc element. Should fail, since @{XSL-T]version must be present

    * fn:current()

        - Have <xsl:value-of select="current()"/>

    * xsl:variable have a variable reference appearing before its global declaration, and then somehow trigger recursion.

    * xsl:choose

        - elements/nodes intermixed with xsl:choose/xsl:when

        - invalid attribute on xsl:choose

        - invalid attribute on xsl:when

        - invalid attribute on xsl:otherwise

        - invalid attribute on xsl:if

        - invalid attribute on xsl:template

        - invalid attribute on xsl:stylesheet

        - invalid attribute on xsl:transform

        - xsl:otherwise in the middle between xsl:when elements.

        - use namespace declarations on xsl:when

        - use namespace declarations on xsl:otherwise

        - use namespace declarations on xsl:choose

    * Namespaces:

        - Have:

            <xsl:sequence xmlns:bar="http://example.com/" select="1"/>

            <xsl:sequence select="bar:foo()"/>

    * XPath

        - For each XQuery-specific expression, add a test using that expression:

            - typeswitch

            - let

            - validate

            - extension expression

            - unordered

            - ordered

            - for

            - computed text node constructor

            - computed attribute constructor

            - computed comment constructor

            - computed PI constructor

            - computed element constructor

            - computed document constructor

            - direct element constructor

            - direct comment constructor

            - direct PI constructor

            - all declarations

        - Use all the predefined prefixes in XQuery; non are in XSL-T.

    * xsl:when

        - Use xml:space on it

    * xsl:otherwise

        - Use xml:space on it

    * xsl:version

        - Use letters, XTSE0110

        - Use a float: 2e3, XTSE0110

        - Use a weird number, 2.00000001

    * xsl:document

        - use disallowed attribute: select.

        - use unknown type in @type

        - use disallowed enumeration in @validation

        - What happens if the type in @type is unknown?

        - Use xml:base attr and check URI.

    * xsl:sequence

        - use match attribute

    * xsl:stylesheet

        - Use @xsl:default-collation on xsl:stylesheet. Shouldn't have any effect. Or?

        - Use an XSL-T instruction as child -- invalid.

        - Have an element in the XSL-T namespace, but which is invalid, e.g "foo"

        - Have xsl:default-collation="http://example.com/" on xsl:stylesheet

        - Use prefix local: in say a function name. Not allowed.

        - Use comments after document element.

        - XTSE0010: <xsl:invalid version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"/>

        - Change the version with @xsl:version on all elements that we have.

    * Patterns.

        - Basic */* test:

            <xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"><xsl:template match="*/*"><xsl:sequence select="'MATCH'"/></xsl:template>

</xsl:stylesheet>

        - Basic a/b test:

            <xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"><xsl:template match="a/b"><xsl:sequence select="'MATCH'"/></xsl:template>

</xsl:stylesheet>

    * xsl:strip-whitespace

        - Use a namespace prefix which is not unboudn

        - have a syntax error in one of the node tests

    * xsl:preserve-whitespace

        - Use a namespace prefix which is not unboudn

        - have a syntax error in one of the node tests

    * xsl:value-of

        - select attribute, and comment in body(error, XTSE0870)

        - select attribute, and processing instruction in body(error, XTSE0870)

        - select attribute, and CCDATA in body(error, XTSE0870)

        - select attribute, and element in body(error, XTSE0870)

        - use xsl:sequence in body. Default separator should be none.

        - use match attribute

        - use double apostrophes/quotes. How are they dealt with?

    * xsl:apply-templates

        - use match attribute

        - apply in a mode for which no templates are declared

        - apply in a mode which is mispelled for another.

        - Have: <xsl:apply-templates select="id('id2')/a | id('id5')"/>

          We CRASH

    * xsl:for-each

        - No body: <xsl:for-each select="abc"/>

        - No select attribute: <xsl:for-each>text</xsl:for-each>

        - Have mixed result, and hence incorrectly trigger  XPTY0018 which the code currently raise.

        - Have:

            <xsl:for-each select="1, 'asd'">

                <xsl:sequence select="."/>

            </xsl:for-each>

    * xsl:variable

        - Test that function conversion rules are invoked

        - For what is an xsl:variable in scope? Where does the spec state it? Test

          that it is not in scope where applicable.

        - Have: <variable name="a" select=""/>

    * xsl:text

        - count the result of a template that has text node(non-ws),

          xsl:text(content), xsl:content(zero content), text node(non-ws

        - Have an element inside xsl:text: XTSE0010.

        - Use comments and PIs intermixed with text inside.

    * xsl:for-each

        - use match attribute

        - What should this produce? Saxon produces "123" but with xsl:text removed, "1 2 3".

                <xsl:template match="/">

                    <xsl:for-each select="1 to 3">

                        <xsl:sequence select="."/>

                        <xsl:text></xsl:text>

                    </xsl:for-each>

                </xsl:template>

    * xsl:if

        - Have <xsl:if test="">body</xsl:if>. Error

        - Have <xsl:if test="valid-test"/>. That is, empty body.

    * xsl:sequence

        - select attribute missing: <xsl:sequence/>

        - content other than xsl:fallback, e.g text node.

        - How do we sort?

    * for every state for XSL-T parsing:

        - Use invalid element that is in the XSL-T namespace.

    * In all cases expressions are queued/generated:

        - Trigger expression precedence bugs, due to lack of paranteses.

    * Use xml:space in stylsheeet that doesn't have value preserve nor default.

    * For each case we have while(!reader.atEnd()):

        - test that triggers parser error and that we detect it properly.

    * for every element that allows text:

        * Use CDATA. QXmlStreamReader distinguishes between the two. text before and after.:wa

        * Use XML Comments and split up text nodes.

    * Patterns:

        * Ensure node() doesn't match document nodes().

        * "//" is an invalid pattern

        * Is there some expression which has no children? findAxisStep()

        * Use @*/asdo

        * XPST0003: key(concat("abc", "def"), "abc")

        * XPST0003: id(concat("abc", "def"))

        * XPST0003: concat('abc', 'def') // WILL CRASH

        * XPST0003: unknownFunction()

        * Use double: key("abc", 3e3)

        * Use three argument key() in pattern.

    * Simplified stylsheet modules:

        * Omit the xsl:version attribute. XTSE0010

    * type-available()

        * We have no tests at all?

    * have xml:base on the following elements and check them with

      static-base-uri():

        - all instructions

        - all declarations, eg:

        - xsl:choose, xsl:choice, xsl:otherwise

        - xsl:template

        - xsl:function

        - etc

    Embedded stylesheet modules

        - Verify that we don't choke on xsl attrs with invalid attributes outside;

          "In an embedded stylesheet module, standard attributes appearing on

          ancestors of the outermost element of the stylesheet module have no effect."

    Parsing:

        - Error message for:

                <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

                    <xsl:template match="/">

                        <e/>

                </xsl:stylesheet>

        - Use the document "<do/" as focus.

        - Write a test for each call to checkForParseError();

    function-available:

        - Generally low coverage it seems.

<xsl:template match="/"/>                   <!-- t0 -->

<xsl:template match="*"/>                   <!-- t1 -->

<xsl:template match="asd"/>                 <!-- t2 -->

<xsl:template match="comment()"/>           <!-- t3 -->

<xsl:template match="a/b"/>                 <!-- t4 -->

<xsl:apply-templates select="*"/>

*(

((/)/call-template(t0))

(*/call-template(t1))

(element(asd)/call-template(t2))

(comment()/call-template(t3))

(a/b/call-template(t3))

)

==>

*/typeswitch(.)

  case $g0 as document-root()   return call-template(t0)

  case $g0 as element()         return call-template(t1)

  case $g0 as element(asd)      return call-template(t2)

  case $g0 as comment()         return (call-template(t3)

  case $g0 as a/b               return (call-template(t4)

Patterns are used in:

    - xsl:for-each-group/@group-starting-with

    - xsl:key/@match

    - xsl:number/(@count, @from)

    - xsl:template/@match

c/b