rust/tests/rustdoc-js-std/parser-tuple.js

const PARSED = [
    {
        query: '(((D, ()))',
        elems: [],
        foundElems: 0,
        userQuery: '(((D, ()))',
        returned: [],
        error: 'Unclosed `(`',
    },
    {
        query: '(((D, ())))',
        elems: [
            {
                name: "()",
                fullPath: ["()"],
                pathWithoutLast: [],
                pathLast: "()",
                generics: [
                    {
                        name: "D",
                        fullPath: ["d"],
                        pathWithoutLast: [],
                        pathLast: "d",
                        generics: [],
                        typeFilter: -1,
                    },
                    {
                        name: "()",
                        fullPath: ["()"],
                        pathWithoutLast: [],
                        pathLast: "()",
                        generics: [],
                        typeFilter: 1,
                    },
                ],
                typeFilter: 1,
            }
        ],
        foundElems: 1,
        userQuery: '(((D, ())))',
        returned: [],
        error: null,
    },
    {
        query: '(),u8',
        elems: [
            {
                name: "()",
                fullPath: ["()"],
                pathWithoutLast: [],
                pathLast: "()",
                generics: [],
                typeFilter: 1,
            },
            {
                name: "u8",
                fullPath: ["u8"],
                pathWithoutLast: [],
                pathLast: "u8",
                generics: [],
                typeFilter: -1,
            },
        ],
        foundElems: 2,
        userQuery: "(),u8",
        returned: [],
        error: null,
    },
    // Parens act as grouping operators when:
    // - there's no commas directly nested within
    // - there's at least two child types (zero means unit)
    // - it's not tagged with a type filter
    // Otherwise, they represent unit and/or tuple. To search for
    // unit or tuple specifically, use `primitive:unit` or `primitive:tuple<...>`.
    {
        query: '(u8)',
        elems: [
            {
                name: "u8",
                fullPath: ["u8"],
                pathWithoutLast: [],
                pathLast: "u8",
                generics: [],
                typeFilter: -1,
            },
        ],
        foundElems: 1,
        userQuery: "(u8)",
        returned: [],
        error: null,
    },
    {
        query: '(u8,)',
        elems: [
            {
                name: "()",
                fullPath: ["()"],
                pathWithoutLast: [],
                pathLast: "()",
                generics: [
                    {
                        name: "u8",
                        fullPath: ["u8"],
                        pathWithoutLast: [],
                        pathLast: "u8",
                        generics: [],
                        typeFilter: -1,
                    },
                ],
                typeFilter: 1,
            },
        ],
        foundElems: 1,
        userQuery: "(u8,)",
        returned: [],
        error: null,
    },
    {
        query: '(,u8)',
        elems: [
            {
                name: "()",
                fullPath: ["()"],
                pathWithoutLast: [],
                pathLast: "()",
                generics: [
                    {
                        name: "u8",
                        fullPath: ["u8"],
                        pathWithoutLast: [],
                        pathLast: "u8",
                        generics: [],
                        typeFilter: -1,
                    },
                ],
                typeFilter: 1,
            },
        ],
        foundElems: 1,
        userQuery: "(,u8)",
        returned: [],
        error: null,
    },
    {
        query: 'primitive:(u8)',
        elems: [
            {
                name: "()",
                fullPath: ["()"],
                pathWithoutLast: [],
                pathLast: "()",
                generics: [
                    {
                        name: "u8",
                        fullPath: ["u8"],
                        pathWithoutLast: [],
                        pathLast: "u8",
                        generics: [],
                        typeFilter: -1,
                    },
                ],
                typeFilter: 1,
            },
        ],
        foundElems: 1,
        userQuery: "primitive:(u8)",
        returned: [],
        error: null,
    },
    {
        query: '(primitive:u8)',
        elems: [
            {
                name: "u8",
                fullPath: ["u8"],
                pathWithoutLast: [],
                pathLast: "u8",
                generics: [],
                typeFilter: 1,
            },
        ],
        foundElems: 1,
        userQuery: "(primitive:u8)",
        returned: [],
        error: null,
    },
    {
        query: '(u8,u8)',
        elems: [
            {
                name: "()",
                fullPath: ["()"],
                pathWithoutLast: [],
                pathLast: "()",
                generics: [
                    {
                        name: "u8",
                        fullPath: ["u8"],
                        pathWithoutLast: [],
                        pathLast: "u8",
                        generics: [],
                        typeFilter: -1,
                    },
                    {
                        name: "u8",
                        fullPath: ["u8"],
                        pathWithoutLast: [],
                        pathLast: "u8",
                        generics: [],
                        typeFilter: -1,
                    },
                ],
                typeFilter: 1,
            },
        ],
        foundElems: 1,
        userQuery: "(u8,u8)",
        returned: [],
        error: null,
    },
    {
        query: '(u8<u8>)',
        elems: [
            {
                name: "u8",
                fullPath: ["u8"],
                pathWithoutLast: [],
                pathLast: "u8",
                generics: [
                    {
                        name: "u8",
                        fullPath: ["u8"],
                        pathWithoutLast: [],
                        pathLast: "u8",
                        generics: [],
                        typeFilter: -1,
                    },
                ],
                typeFilter: -1,
            },
        ],
        foundElems: 1,
        userQuery: "(u8<u8>)",
        returned: [],
        error: null,
    },
    {
        query: '()',
        elems: [
            {
                name: "()",
                fullPath: ["()"],
                pathWithoutLast: [],
                pathLast: "()",
                generics: [],
                typeFilter: 1,
            },
        ],
        foundElems: 1,
        userQuery: "()",
        returned: [],
        error: null,
    },
    {
        query: '(>',
        elems: [],
        foundElems: 0,
        userQuery: "(>",
        returned: [],
        error: "Unexpected `>` after `(`",
    },
    {
        query: '(<',
        elems: [],
        foundElems: 0,
        userQuery: "(<",
        returned: [],
        error: "Found generics without a path",
    },
    {
        query: '(a>',
        elems: [],
        foundElems: 0,
        userQuery: "(a>",
        returned: [],
        error: "Unexpected `>` after `(`",
    },
    {
        query: '(a<',
        elems: [],
        foundElems: 0,
        userQuery: "(a<",
        returned: [],
        error: "Unclosed `<`",
    },
    {
        query: '(a',
        elems: [],
        foundElems: 0,
        userQuery: "(a",
        returned: [],
        error: "Unclosed `(`",
    },
    {
        query: '(',
        elems: [],
        foundElems: 0,
        userQuery: "(",
        returned: [],
        error: "Unclosed `(`",
    },
    {
        query: ')',
        elems: [],
        foundElems: 0,
        userQuery: ")",
        returned: [],
        error: "Unexpected `)`",
    },
    {
        query: '(a<b>',
        elems: [],
        foundElems: 0,
        userQuery: "(a<b>",
        returned: [],
        error: "Unclosed `(`",
    },
    {
        query: 'a<b>)',
        elems: [],
        foundElems: 0,
        userQuery: "a<b>)",
        returned: [],
        error: "Unexpected `)` after `>`",
    },
    {
        query: 'macro:(u8)',
        elems: [],
        foundElems: 0,
        userQuery: "macro:(u8)",
        returned: [],
        error: "Invalid search type: primitive `()` and `macro` both specified",
    },
];