src/test/rustdoc-js-std/parser-errors.js

   1 const QUERY = [
   2     '<P>',
   3     '-> <P>',
   4     'a<"P">',
   5     '"P" "P"',
   6     'P "P"',
   7     '"p" p',
   8     '"const": p',
   9     "a<:a>",
  10     "a<::a>",
  11     "((a))",
  12     "(p -> p",
  13     "::a::b",
  14     "a::::b",
  15     "a::b::",
  16     ":a",
  17     "a b:",
  18     "a (b:",
  19     "_:",
  20     "a-bb",
  21     "a>bb",
  22     "ab'",
  23     "a->",
  24     '"p" <a>',
  25     '"p" a<a>',
  26     "a,<",
  27     "aaaaa<>b",
  28     "fn:aaaaa<>b",
  29     "->a<>b",
  30 ];
  31
  32 const PARSED = [
  33     {
  34         elems: [],
  35         foundElems: 0,
  36         original: "<P>",
  37         returned: [],
  38         typeFilter: -1,
  39         userQuery: "<p>",
  40         error: "Found generics without a path",
  41     },
  42     {
  43         elems: [],
  44         foundElems: 0,
  45         original: "-> <P>",
  46         returned: [],
  47         typeFilter: -1,
  48         userQuery: "-> <p>",
  49         error: "Found generics without a path",
  50     },
  51     {
  52         elems: [],
  53         foundElems: 0,
  54         original: "a<\"P\">",
  55         returned: [],
  56         typeFilter: -1,
  57         userQuery: "a<\"p\">",
  58         error: "`\"` cannot be used in generics",
  59     },
  60     {
  61         elems: [],
  62         foundElems: 0,
  63         original: "\"P\" \"P\"",
  64         returned: [],
  65         typeFilter: -1,
  66         userQuery: "\"p\" \"p\"",
  67         error: "Cannot have more than one literal search element",
  68     },
  69     {
  70         elems: [],
  71         foundElems: 0,
  72         original: "P \"P\"",
  73         returned: [],
  74         typeFilter: -1,
  75         userQuery: "p \"p\"",
  76         error: "Cannot use literal search when there is more than one element",
  77     },
  78     {
  79         elems: [],
  80         foundElems: 0,
  81         original: "\"p\" p",
  82         returned: [],
  83         typeFilter: -1,
  84         userQuery: "\"p\" p",
  85         error: "You cannot have more than one element if you use quotes",
  86     },
  87     {
  88         elems: [],
  89         foundElems: 0,
  90         original: "\"const\": p",
  91         returned: [],
  92         typeFilter: -1,
  93         userQuery: "\"const\": p",
  94         error: "You cannot use quotes on type filter",
  95     },
  96     {
  97         elems: [],
  98         foundElems: 0,
  99         original: "a<:a>",
 100         returned: [],
 101         typeFilter: -1,
 102         userQuery: "a<:a>",
 103         error: "Unexpected `:` after `<`",
 104     },
 105     {
 106         elems: [],
 107         foundElems: 0,
 108         original: "a<::a>",
 109         returned: [],
 110         typeFilter: -1,
 111         userQuery: "a<::a>",
 112         error: "Unexpected `::`: paths cannot start with `::`",
 113     },
 114     {
 115         elems: [],
 116         foundElems: 0,
 117         original: "((a))",
 118         returned: [],
 119         typeFilter: -1,
 120         userQuery: "((a))",
 121         error: "Unexpected `(`",
 122     },
 123     {
 124         elems: [],
 125         foundElems: 0,
 126         original: "(p -> p",
 127         returned: [],
 128         typeFilter: -1,
 129         userQuery: "(p -> p",
 130         error: "Unexpected `(`",
 131     },
 132     {
 133         elems: [],
 134         foundElems: 0,
 135         original: "::a::b",
 136         returned: [],
 137         typeFilter: -1,
 138         userQuery: "::a::b",
 139         error: "Paths cannot start with `::`",
 140     },
 141     {
 142         elems: [],
 143         foundElems: 0,
 144         original: "a::::b",
 145         returned: [],
 146         typeFilter: -1,
 147         userQuery: "a::::b",
 148         error: "Unexpected `::::`",
 149     },
 150     {
 151         elems: [],
 152         foundElems: 0,
 153         original: "a::b::",
 154         returned: [],
 155         typeFilter: -1,
 156         userQuery: "a::b::",
 157         error: "Paths cannot end with `::`",
 158     },
 159     {
 160         elems: [],
 161         foundElems: 0,
 162         original: ":a",
 163         returned: [],
 164         typeFilter: -1,
 165         userQuery: ":a",
 166         error: "Expected type filter before `:`",
 167     },
 168     {
 169         elems: [],
 170         foundElems: 0,
 171         original: "a b:",
 172         returned: [],
 173         typeFilter: -1,
 174         userQuery: "a b:",
 175         error: "Unexpected `:`",
 176     },
 177     {
 178         elems: [],
 179         foundElems: 0,
 180         original: "a (b:",
 181         returned: [],
 182         typeFilter: -1,
 183         userQuery: "a (b:",
 184         error: "Unexpected `(`",
 185     },
 186     {
 187         elems: [],
 188         foundElems: 0,
 189         original: "_:",
 190         returned: [],
 191         typeFilter: -1,
 192         userQuery: "_:",
 193         error: "Unknown type filter `_`",
 194     },
 195     {
 196         elems: [],
 197         foundElems: 0,
 198         original: "a-bb",
 199         returned: [],
 200         typeFilter: -1,
 201         userQuery: "a-bb",
 202         error: "Unexpected `-` (did you mean `->`?)",
 203     },
 204     {
 205         elems: [],
 206         foundElems: 0,
 207         original: "a>bb",
 208         returned: [],
 209         typeFilter: -1,
 210         userQuery: "a>bb",
 211         error: "Unexpected `>` (did you mean `->`?)",
 212     },
 213     {
 214         elems: [],
 215         foundElems: 0,
 216         original: "ab'",
 217         returned: [],
 218         typeFilter: -1,
 219         userQuery: "ab'",
 220         error: "Unexpected `'`",
 221     },
 222     {
 223         elems: [],
 224         foundElems: 0,
 225         original: "a->",
 226         returned: [],
 227         typeFilter: -1,
 228         userQuery: "a->",
 229         error: "Expected at least one item after `->`",
 230     },
 231     {
 232         elems: [],
 233         foundElems: 0,
 234         original: '"p" <a>',
 235         returned: [],
 236         typeFilter: -1,
 237         userQuery: '"p" <a>',
 238         error: "Found generics without a path",
 239     },
 240     {
 241         elems: [],
 242         foundElems: 0,
 243         original: '"p" a<a>',
 244         returned: [],
 245         typeFilter: -1,
 246         userQuery: '"p" a<a>',
 247         error: "You cannot have more than one element if you use quotes",
 248     },
 249     {
 250         elems: [],
 251         foundElems: 0,
 252         original: 'a,<',
 253         returned: [],
 254         typeFilter: -1,
 255         userQuery: 'a,<',
 256         error: 'Found generics without a path',
 257     },
 258     {
 259         elems: [],
 260         foundElems: 0,
 261         original: 'aaaaa<>b',
 262         returned: [],
 263         typeFilter: -1,
 264         userQuery: 'aaaaa<>b',
 265         error: 'Expected `,`, ` `, `:` or `->`, found `b`',
 266     },
 267     {
 268         elems: [],
 269         foundElems: 0,
 270         original: 'fn:aaaaa<>b',
 271         returned: [],
 272         typeFilter: -1,
 273         userQuery: 'fn:aaaaa<>b',
 274         error: 'Expected `,`, ` ` or `->`, found `b`',
 275     },
 276     {
 277         elems: [],
 278         foundElems: 0,
 279         original: '->a<>b',
 280         returned: [],
 281         typeFilter: -1,
 282         userQuery: '->a<>b',
 283         error: 'Expected `,` or ` `, found `b`',
 284     },
 285 ];