diff options
Diffstat (limited to 'tests/rustdoc-js-std')
52 files changed, 4536 insertions, 0 deletions
diff --git a/tests/rustdoc-js-std/alias-1.js b/tests/rustdoc-js-std/alias-1.js new file mode 100644 index 00000000000..c31d1a3b1ad --- /dev/null +++ b/tests/rustdoc-js-std/alias-1.js @@ -0,0 +1,10 @@ +const EXPECTED = { + 'query': '&', + 'others': [ + { + 'path': 'std', + 'name': 'reference', + 'desc': "References, <code>&T</code> and <code>&mut T</code>.", + }, + ], +}; diff --git a/tests/rustdoc-js-std/alias-2.js b/tests/rustdoc-js-std/alias-2.js new file mode 100644 index 00000000000..5735b573bcb --- /dev/null +++ b/tests/rustdoc-js-std/alias-2.js @@ -0,0 +1,9 @@ +const EXPECTED = { + 'query': '+', + 'others': [ + { 'path': 'std::ops', 'name': 'AddAssign' }, + { 'path': 'std::ops', 'name': 'Add' }, + { 'path': 'core::ops', 'name': 'AddAssign' }, + { 'path': 'core::ops', 'name': 'Add' }, + ], +}; diff --git a/tests/rustdoc-js-std/alias-3.js b/tests/rustdoc-js-std/alias-3.js new file mode 100644 index 00000000000..ed3776b3c2a --- /dev/null +++ b/tests/rustdoc-js-std/alias-3.js @@ -0,0 +1,6 @@ +const EXPECTED = { + 'query': '!', + 'others': [ + { 'path': 'std', 'name': 'never' }, + ], +}; diff --git a/tests/rustdoc-js-std/alias-4.js b/tests/rustdoc-js-std/alias-4.js new file mode 100644 index 00000000000..35840a472c1 --- /dev/null +++ b/tests/rustdoc-js-std/alias-4.js @@ -0,0 +1,6 @@ +const EXPECTED = { + 'query': '<', + 'others': [ + { 'name': 'Ord' }, + ], +}; diff --git a/tests/rustdoc-js-std/alias.js b/tests/rustdoc-js-std/alias.js new file mode 100644 index 00000000000..bf707fa03dc --- /dev/null +++ b/tests/rustdoc-js-std/alias.js @@ -0,0 +1,10 @@ +// ignore-order + +const EXPECTED = { + 'query': '[', + 'others': [ + { 'path': 'std', 'name': 'slice' }, + { 'path': 'std::ops', 'name': 'IndexMut' }, + { 'path': 'std::ops', 'name': 'Index' }, + ], +}; diff --git a/tests/rustdoc-js-std/asrawfd.js b/tests/rustdoc-js-std/asrawfd.js new file mode 100644 index 00000000000..5dbc4ba95d9 --- /dev/null +++ b/tests/rustdoc-js-std/asrawfd.js @@ -0,0 +1,12 @@ +// ignore-order + +const EXPECTED = { + 'query': 'RawFd::as_raw_fd', + 'others': [ + // Reproduction test for https://github.com/rust-lang/rust/issues/78724 + // Validate that type alias methods get the correct path. + { 'path': 'std::os::fd::AsRawFd', 'name': 'as_raw_fd' }, + { 'path': 'std::os::fd::AsRawFd', 'name': 'as_raw_fd' }, + { 'path': 'std::os::fd::RawFd', 'name': 'as_raw_fd' }, + ], +}; diff --git a/tests/rustdoc-js-std/basic.js b/tests/rustdoc-js-std/basic.js new file mode 100644 index 00000000000..baff24b0af6 --- /dev/null +++ b/tests/rustdoc-js-std/basic.js @@ -0,0 +1,14 @@ +const EXPECTED = { + 'query': 'String', + 'others': [ + { 'path': 'std::string', 'name': 'String' }, + { 'path': 'std::ffi', 'name': 'CString' }, + { 'path': 'std::ffi', 'name': 'OsString' }, + ], + 'in_args': [ + { 'path': 'std::str', 'name': 'eq' }, + ], + 'returned': [ + { 'path': 'std::string::String', 'name': 'add' }, + ], +}; diff --git a/tests/rustdoc-js-std/bufread-fill-buf.js b/tests/rustdoc-js-std/bufread-fill-buf.js new file mode 100644 index 00000000000..3828cf76026 --- /dev/null +++ b/tests/rustdoc-js-std/bufread-fill-buf.js @@ -0,0 +1,13 @@ +// ignore-order + +const EXPECTED = [ + { + 'query': 'bufread -> result<u8>', + 'others': [ + { 'path': 'std::io::Split', 'name': 'next' }, + { 'path': 'std::boxed::Box', 'name': 'fill_buf' }, + { 'path': 'std::io::Chain', 'name': 'fill_buf' }, + { 'path': 'std::io::Take', 'name': 'fill_buf' }, + ], + }, +]; diff --git a/tests/rustdoc-js-std/deduplication.js b/tests/rustdoc-js-std/deduplication.js new file mode 100644 index 00000000000..51279dd5ed4 --- /dev/null +++ b/tests/rustdoc-js-std/deduplication.js @@ -0,0 +1,10 @@ +// ignore-order + +const EXPECTED = { + 'query': 'is_nan', + 'others': [ + { 'path': 'std::f32', 'name': 'is_nan' }, + { 'path': 'std::f64', 'name': 'is_nan' }, + { 'path': 'std::option::Option', 'name': 'is_none' }, + ], +}; diff --git a/tests/rustdoc-js-std/enum-option.js b/tests/rustdoc-js-std/enum-option.js new file mode 100644 index 00000000000..216dafe3b12 --- /dev/null +++ b/tests/rustdoc-js-std/enum-option.js @@ -0,0 +1,6 @@ +const EXPECTED = { + 'query': 'enum:Option', + 'others': [ + { 'path': 'std::option', 'name': 'Option' }, + ], +}; diff --git a/tests/rustdoc-js-std/filter-crate.js b/tests/rustdoc-js-std/filter-crate.js new file mode 100644 index 00000000000..95f2969d299 --- /dev/null +++ b/tests/rustdoc-js-std/filter-crate.js @@ -0,0 +1,9 @@ +// exact-check + +const FILTER_CRATE = 'core'; + +const EXPECTED = { + 'query': 'hashmap', + 'others': [ + ], +}; diff --git a/tests/rustdoc-js-std/fn-forget.js b/tests/rustdoc-js-std/fn-forget.js new file mode 100644 index 00000000000..addecf4e44f --- /dev/null +++ b/tests/rustdoc-js-std/fn-forget.js @@ -0,0 +1,7 @@ +const EXPECTED = { + 'query': 'fn:forget', + 'others': [ + { 'path': 'std::mem', 'name': 'forget' }, + { 'path': 'std::fmt', 'name': 'format' }, + ], +}; diff --git a/tests/rustdoc-js-std/from_u.js b/tests/rustdoc-js-std/from_u.js new file mode 100644 index 00000000000..7c9375ba529 --- /dev/null +++ b/tests/rustdoc-js-std/from_u.js @@ -0,0 +1,8 @@ +const EXPECTED = { + 'query': 'from_u', + 'others': [ + { 'path': 'std::char', 'name': 'from_u32' }, + { 'path': 'std::str', 'name': 'from_utf8' }, + { 'path': 'std::string::String', 'name': 'from_utf8' }, + ], +}; diff --git a/tests/rustdoc-js-std/full-path-function.js b/tests/rustdoc-js-std/full-path-function.js new file mode 100644 index 00000000000..ac157b3aadf --- /dev/null +++ b/tests/rustdoc-js-std/full-path-function.js @@ -0,0 +1,7 @@ +const EXPECTED = { + 'query': 'vec::vec -> usize', + 'others': [ + { 'path': 'std::vec::Vec', 'name': 'len' }, + { 'path': 'std::vec::Vec', 'name': 'capacity' }, + ], +}; diff --git a/tests/rustdoc-js-std/iterator-type-signatures.js b/tests/rustdoc-js-std/iterator-type-signatures.js new file mode 100644 index 00000000000..c18ffc1651c --- /dev/null +++ b/tests/rustdoc-js-std/iterator-type-signatures.js @@ -0,0 +1,29 @@ +// ignore-order + +const FILTER_CRATE = "std"; + +const EXPECTED = [ + { + 'query': 'iterator<t> -> option<t>', + 'others': [ + { 'path': 'std::iter::Iterator', 'name': 'max' }, + { 'path': 'std::iter::Iterator', 'name': 'min' }, + { 'path': 'std::iter::Iterator', 'name': 'last' }, + { 'path': 'std::iter::Iterator', 'name': 'next' }, + ], + }, + { + 'query': 'iterator<t>, usize -> option<t>', + 'others': [ + { 'path': 'std::iter::Iterator', 'name': 'nth' }, + ], + }, + { + // Something should be done so that intoiterator is considered a match + // for plain iterator. + 'query': 'iterator<t>, intoiterator<t> -> ordering', + 'others': [ + { 'path': 'std::iter::Iterator', 'name': 'cmp' }, + ], + }, +]; diff --git a/tests/rustdoc-js-std/keyword.js b/tests/rustdoc-js-std/keyword.js new file mode 100644 index 00000000000..1837b1e71f7 --- /dev/null +++ b/tests/rustdoc-js-std/keyword.js @@ -0,0 +1,9 @@ +// ignore-order + +const EXPECTED = { + 'query': 'fn', + 'others': [ + { 'path': 'std', 'name': 'fn', ty: 1 }, // 1 is for primitive types + { 'path': 'std', 'name': 'fn', ty: 0 }, // 0 is for keywords + ], +}; diff --git a/tests/rustdoc-js-std/macro-check.js b/tests/rustdoc-js-std/macro-check.js new file mode 100644 index 00000000000..37d5e7dae62 --- /dev/null +++ b/tests/rustdoc-js-std/macro-check.js @@ -0,0 +1,9 @@ +// ignore-order + +const EXPECTED = { + 'query': 'panic', + 'others': [ + { 'path': 'std', 'name': 'panic', ty: 16 }, // 16 is for macros + { 'path': 'std', 'name': 'panic', ty: 2 }, // 2 is for modules + ], +}; diff --git a/tests/rustdoc-js-std/macro-print.js b/tests/rustdoc-js-std/macro-print.js new file mode 100644 index 00000000000..2ef1c89e49b --- /dev/null +++ b/tests/rustdoc-js-std/macro-print.js @@ -0,0 +1,9 @@ +const EXPECTED = { + 'query': 'macro:print', + 'others': [ + { 'path': 'std', 'name': 'print' }, + { 'path': 'std', 'name': 'println' }, + { 'path': 'std', 'name': 'eprint' }, + { 'path': 'std', 'name': 'eprintln' }, + ], +}; diff --git a/tests/rustdoc-js-std/never.js b/tests/rustdoc-js-std/never.js new file mode 100644 index 00000000000..27d415b5e48 --- /dev/null +++ b/tests/rustdoc-js-std/never.js @@ -0,0 +1,14 @@ +const EXPECTED = [ + { + 'query': '!', + 'others': [ + { 'path': 'std', 'name': 'never' }, + ], + }, + { + 'query': '!::clone', + 'others': [ + { 'path': 'std::never', 'name': 'clone' }, + ], + }, +]; diff --git a/tests/rustdoc-js-std/option-type-signatures.js b/tests/rustdoc-js-std/option-type-signatures.js new file mode 100644 index 00000000000..e154fa707ab --- /dev/null +++ b/tests/rustdoc-js-std/option-type-signatures.js @@ -0,0 +1,84 @@ +// ignore-order + +const FILTER_CRATE = "std"; + +const EXPECTED = [ + { + 'query': 'option, fnonce -> option', + 'others': [ + { 'path': 'std::option::Option', 'name': 'map' }, + ], + }, + { + 'query': 'option -> default', + 'others': [ + { 'path': 'std::option::Option', 'name': 'unwrap_or_default' }, + { 'path': 'std::option::Option', 'name': 'get_or_insert_default' }, + ], + }, + { + 'query': 'option -> []', + 'others': [ + { 'path': 'std::option::Option', 'name': 'as_slice' }, + { 'path': 'std::option::Option', 'name': 'as_mut_slice' }, + ], + }, + { + 'query': 'option<t>, option<t> -> option<t>', + 'others': [ + { 'path': 'std::option::Option', 'name': 'or' }, + { 'path': 'std::option::Option', 'name': 'xor' }, + ], + }, + { + 'query': 'option<t>, option<u> -> option<u>', + 'others': [ + { 'path': 'std::option::Option', 'name': 'and' }, + { 'path': 'std::option::Option', 'name': 'zip' }, + ], + }, + { + 'query': 'option<t>, option<u> -> option<t>', + 'others': [ + { 'path': 'std::option::Option', 'name': 'and' }, + { 'path': 'std::option::Option', 'name': 'zip' }, + ], + }, + { + 'query': 'option<t>, option<u> -> option<t, u>', + 'others': [ + { 'path': 'std::option::Option', 'name': 'zip' }, + ], + }, + { + 'query': 'option<t>, e -> result<t, e>', + 'others': [ + { 'path': 'std::option::Option', 'name': 'ok_or' }, + { 'path': 'std::result::Result', 'name': 'transpose' }, + ], + }, + { + 'query': 'result<option<t>, e> -> option<result<t, e>>', + 'others': [ + { 'path': 'std::result::Result', 'name': 'transpose' }, + ], + }, + { + 'query': 'option<t>, option<t> -> bool', + 'others': [ + { 'path': 'std::option::Option', 'name': 'eq' }, + ], + }, + { + 'query': 'option<option<t>> -> option<t>', + 'others': [ + { 'path': 'std::option::Option', 'name': 'flatten' }, + ], + }, + { + 'query': 'option<t>', + 'returned': [ + { 'path': 'std::result::Result', 'name': 'ok' }, + ], + }, +]; diff --git a/tests/rustdoc-js-std/osstring-to-string.js b/tests/rustdoc-js-std/osstring-to-string.js new file mode 100644 index 00000000000..3fdc0b9f24a --- /dev/null +++ b/tests/rustdoc-js-std/osstring-to-string.js @@ -0,0 +1,9 @@ +// exact-match + +// https://github.com/rust-lang/rust/issues/60485#issuecomment-663900624 +const EXPECTED = { + 'query': 'OsString -> String', + 'others': [ + { 'path': 'std::ffi::os_str::OsString', 'name': 'into_string' }, + ] +}; diff --git a/tests/rustdoc-js-std/parser-bindings.js b/tests/rustdoc-js-std/parser-bindings.js new file mode 100644 index 00000000000..c4909c6242d --- /dev/null +++ b/tests/rustdoc-js-std/parser-bindings.js @@ -0,0 +1,245 @@ +const PARSED = [ + { + query: 'A<B=C>', + elems: [ + { + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + bindings: [ + [ + 'b', + [ + { + name: "c", + fullPath: ["c"], + pathWithoutLast: [], + pathLast: "c", + generics: [], + typeFilter: -1, + }, + ] + ], + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: 'A<B=C>', + returned: [], + userQuery: 'a<b=c>', + error: null, + }, + { + query: 'A<B = C>', + elems: [ + { + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + bindings: [ + [ + 'b', + [{ + name: "c", + fullPath: ["c"], + pathWithoutLast: [], + pathLast: "c", + generics: [], + typeFilter: -1, + }] + ], + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: 'A<B = C>', + returned: [], + userQuery: 'a<b = c>', + error: null, + }, + { + query: 'A<B=!>', + elems: [ + { + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + bindings: [ + [ + 'b', + [{ + name: "never", + fullPath: ["never"], + pathWithoutLast: [], + pathLast: "never", + generics: [], + typeFilter: 1, + }] + ], + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: 'A<B=!>', + returned: [], + userQuery: 'a<b=!>', + error: null, + }, + { + query: 'A<B=[]>', + elems: [ + { + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + bindings: [ + [ + 'b', + [{ + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [], + typeFilter: 1, + }] + ], + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: 'A<B=[]>', + returned: [], + userQuery: 'a<b=[]>', + error: null, + }, + { + query: 'A<B=[!]>', + elems: [ + { + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + bindings: [ + [ + 'b', + [{ + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [ + { + name: "never", + fullPath: ["never"], + pathWithoutLast: [], + pathLast: "never", + generics: [], + typeFilter: 1, + }, + ], + typeFilter: 1, + }] + ], + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: 'A<B=[!]>', + returned: [], + userQuery: 'a<b=[!]>', + error: null, + }, + { + query: 'A<B=C=>', + elems: [], + foundElems: 0, + original: 'A<B=C=>', + returned: [], + userQuery: 'a<b=c=>', + error: "Cannot write `=` twice in a binding", + }, + { + query: 'A<B=>', + elems: [], + foundElems: 0, + original: 'A<B=>', + returned: [], + userQuery: 'a<b=>', + error: "Unexpected `>` after `=`", + }, + { + query: 'B=C', + elems: [], + foundElems: 0, + original: 'B=C', + returned: [], + userQuery: 'b=c', + error: "Type parameter `=` must be within generics list", + }, + { + query: '[B=C]', + elems: [], + foundElems: 0, + original: '[B=C]', + returned: [], + userQuery: '[b=c]', + error: "Type parameter `=` cannot be within slice `[]`", + }, + { + query: 'A<B<X>=C>', + elems: [ + { + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + bindings: [ + [ + 'b', + [ + { + name: "c", + fullPath: ["c"], + pathWithoutLast: [], + pathLast: "c", + generics: [], + typeFilter: -1, + }, + { + name: "x", + fullPath: ["x"], + pathWithoutLast: [], + pathLast: "x", + generics: [], + typeFilter: -1, + }, + ], + ], + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: 'A<B<X>=C>', + returned: [], + userQuery: 'a<b<x>=c>', + error: null, + }, +]; diff --git a/tests/rustdoc-js-std/parser-errors.js b/tests/rustdoc-js-std/parser-errors.js new file mode 100644 index 00000000000..c4d7c2b0b85 --- /dev/null +++ b/tests/rustdoc-js-std/parser-errors.js @@ -0,0 +1,565 @@ +const PARSED = [ + { + query: '<P>', + elems: [], + foundElems: 0, + original: "<P>", + returned: [], + userQuery: "<p>", + error: "Found generics without a path", + }, + { + query: '-> <P>', + elems: [], + foundElems: 0, + original: "-> <P>", + returned: [], + userQuery: "-> <p>", + error: "Found generics without a path", + }, + { + query: '-> *', + elems: [], + foundElems: 0, + original: "-> *", + returned: [], + userQuery: "-> *", + error: "Unexpected `*` after ` ` (not a valid identifier)", + }, + { + query: 'a<"P">', + elems: [], + foundElems: 0, + original: "a<\"P\">", + returned: [], + userQuery: "a<\"p\">", + error: "Unexpected `\"` in generics", + }, + { + query: '"P" "P"', + elems: [], + foundElems: 0, + original: "\"P\" \"P\"", + returned: [], + userQuery: "\"p\" \"p\"", + error: "Cannot have more than one element if you use quotes", + }, + { + query: '"P","P"', + elems: [], + foundElems: 0, + original: "\"P\",\"P\"", + returned: [], + userQuery: "\"p\",\"p\"", + error: "Cannot have more than one literal search element", + }, + { + query: "P,\"P\"", + elems: [], + foundElems: 0, + original: "P,\"P\"", + returned: [], + userQuery: "p,\"p\"", + error: "Cannot use literal search when there is more than one element", + }, + { + query: '"p" p', + elems: [], + foundElems: 0, + original: "\"p\" p", + returned: [], + userQuery: "\"p\" p", + error: "Cannot have more than one element if you use quotes", + }, + { + query: '"p",p', + elems: [], + foundElems: 0, + original: "\"p\",p", + returned: [], + userQuery: "\"p\",p", + error: "Cannot have more than one element if you use quotes", + }, + { + query: '"const": p', + elems: [], + foundElems: 0, + original: "\"const\": p", + returned: [], + userQuery: "\"const\": p", + error: "Cannot use quotes on type filter", + }, + { + query: "a<:a>", + elems: [], + foundElems: 0, + original: "a<:a>", + returned: [], + userQuery: "a<:a>", + error: "Expected type filter before `:`", + }, + { + query: "a<::a>", + elems: [], + foundElems: 0, + original: "a<::a>", + returned: [], + userQuery: "a<::a>", + error: "Unexpected `::`: paths cannot start with `::`", + }, + { + query: "(p -> p", + elems: [], + foundElems: 0, + original: "(p -> p", + returned: [], + userQuery: "(p -> p", + error: "Unclosed `(`", + }, + { + query: "::a::b", + elems: [], + foundElems: 0, + original: "::a::b", + returned: [], + userQuery: "::a::b", + error: "Paths cannot start with `::`", + }, + { + query: " ::a::b", + elems: [], + foundElems: 0, + original: "::a::b", + returned: [], + userQuery: "::a::b", + error: "Paths cannot start with `::`", + }, + { + query: "a::::b", + elems: [], + foundElems: 0, + original: "a::::b", + returned: [], + userQuery: "a::::b", + error: "Unexpected `::::`", + }, + { + query: "a:: ::b", + elems: [], + foundElems: 0, + original: "a:: ::b", + returned: [], + userQuery: "a:: ::b", + error: "Unexpected `:: ::`", + }, + { + query: "a::\t::b", + elems: [], + foundElems: 0, + original: "a:: ::b", + returned: [], + userQuery: "a:: ::b", + error: "Unexpected `:: ::`", + }, + { + query: "a::b::", + elems: [], + foundElems: 0, + original: "a::b::", + returned: [], + userQuery: "a::b::", + error: "Paths cannot end with `::`", + }, + { + query: ":a", + elems: [], + foundElems: 0, + original: ":a", + returned: [], + userQuery: ":a", + error: "Expected type filter before `:`", + }, + { + query: "a,b:", + elems: [], + foundElems: 0, + original: "a,b:", + returned: [], + userQuery: "a,b:", + error: "Unexpected `:` (expected path after type filter `b:`)", + }, + { + query: "a (b:", + elems: [], + foundElems: 0, + original: "a (b:", + returned: [], + userQuery: "a (b:", + error: "Unclosed `(`", + }, + { + query: "_:", + elems: [], + foundElems: 0, + original: "_:", + returned: [], + userQuery: "_:", + error: "Unexpected `_` (not a valid identifier)", + }, + { + query: "ab:", + elems: [], + foundElems: 0, + original: "ab:", + returned: [], + userQuery: "ab:", + error: "Unexpected `:` (expected path after type filter `ab:`)", + }, + { + query: "a:b", + elems: [], + foundElems: 0, + original: "a:b", + returned: [], + userQuery: "a:b", + error: "Unknown type filter `a`", + }, + { + query: "a-bb", + elems: [], + foundElems: 0, + original: "a-bb", + returned: [], + userQuery: "a-bb", + error: "Unexpected `-` (did you mean `->`?)", + }, + { + query: "a>bb", + elems: [], + foundElems: 0, + original: "a>bb", + returned: [], + userQuery: "a>bb", + error: "Unexpected `>` (did you mean `->`?)", + }, + { + query: "ab'", + elems: [], + foundElems: 0, + original: "ab'", + returned: [], + userQuery: "ab'", + error: "Unexpected `'` after `b` (not a valid identifier)", + }, + { + query: "a->", + elems: [], + foundElems: 0, + original: "a->", + returned: [], + userQuery: "a->", + error: "Expected at least one item after `->`", + }, + { + query: '"p" <a>', + elems: [], + foundElems: 0, + original: '"p" <a>', + returned: [], + userQuery: '"p" <a>', + error: "Cannot have more than one element if you use quotes", + }, + { + query: '"p",<a>', + elems: [], + foundElems: 0, + original: '"p",<a>', + returned: [], + userQuery: '"p",<a>', + error: "Found generics without a path", + }, + { + query: '"p" a<a>', + elems: [], + foundElems: 0, + original: '"p" a<a>', + returned: [], + userQuery: '"p" a<a>', + error: "Cannot have more than one element if you use quotes", + }, + { + query: '"p",a<a>', + elems: [], + foundElems: 0, + original: '"p",a<a>', + returned: [], + userQuery: '"p",a<a>', + error: "Cannot have more than one element if you use quotes", + }, + { + query: "a,<", + elems: [], + foundElems: 0, + original: 'a,<', + returned: [], + userQuery: 'a,<', + error: 'Found generics without a path', + }, + { + query: "aaaaa<>b", + elems: [], + foundElems: 0, + original: 'aaaaa<>b', + returned: [], + userQuery: 'aaaaa<>b', + error: 'Expected `,`, `:` or `->` after `>`, found `b`', + }, + { + query: "fn:aaaaa<>b", + elems: [], + foundElems: 0, + original: 'fn:aaaaa<>b', + returned: [], + userQuery: 'fn:aaaaa<>b', + error: 'Expected `,`, `:` or `->` after `>`, found `b`', + }, + { + query: "->a<>b", + elems: [], + foundElems: 0, + original: '->a<>b', + returned: [], + userQuery: '->a<>b', + error: 'Expected `,` or `=` after `>`, found `b`', + }, + { + query: "a<->", + elems: [], + foundElems: 0, + original: 'a<->', + returned: [], + userQuery: 'a<->', + error: 'Unclosed `<`', + }, + { + query: "a<a>:", + elems: [], + foundElems: 0, + original: "a<a>:", + returned: [], + userQuery: "a<a>:", + error: 'Unexpected `<` in type filter (before `:`)', + }, + { + query: "a<>:", + elems: [], + foundElems: 0, + original: "a<>:", + returned: [], + userQuery: "a<>:", + error: 'Unexpected `<` in type filter (before `:`)', + }, + { + query: "a,:", + elems: [], + foundElems: 0, + original: "a,:", + returned: [], + userQuery: "a,:", + error: 'Expected type filter before `:`', + }, + { + query: "a!:", + elems: [], + foundElems: 0, + original: "a!:", + returned: [], + userQuery: "a!:", + error: 'Unexpected `!` in type filter (before `:`)', + }, + { + query: " a<> :", + elems: [], + foundElems: 0, + original: "a<> :", + returned: [], + userQuery: "a<> :", + error: 'Expected `,`, `:` or `->` after `>`, found `:`', + }, + { + query: "mod : :", + elems: [], + foundElems: 0, + original: "mod : :", + returned: [], + userQuery: "mod : :", + error: 'Unexpected `:` (expected path after type filter `mod:`)', + }, + { + query: "mod: :", + elems: [], + foundElems: 0, + original: "mod: :", + returned: [], + userQuery: "mod: :", + error: 'Unexpected `:` (expected path after type filter `mod:`)', + }, + { + query: "a!a", + elems: [], + foundElems: 0, + original: "a!a", + returned: [], + userQuery: "a!a", + error: 'Unexpected `!`: it can only be at the end of an ident', + }, + { + query: "a!!", + elems: [], + foundElems: 0, + original: "a!!", + returned: [], + userQuery: "a!!", + error: 'Cannot have more than one `!` in an ident', + }, + { + query: "mod:a!", + elems: [], + foundElems: 0, + original: "mod:a!", + returned: [], + userQuery: "mod:a!", + error: 'Invalid search type: macro `!` and `mod` both specified', + }, + { + query: "mod:!", + elems: [], + foundElems: 0, + original: "mod:!", + returned: [], + userQuery: "mod:!", + error: 'Invalid search type: primitive never type `!` and `mod` both specified', + }, + { + query: "a!::a", + elems: [], + foundElems: 0, + original: "a!::a", + returned: [], + userQuery: "a!::a", + error: 'Cannot have associated items in macros', + }, + { + query: "a<", + elems: [], + foundElems: 0, + original: "a<", + returned: [], + userQuery: "a<", + error: "Unclosed `<`", + }, + { + query: "p<x> , y", + elems: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [ + { + name: "x", + fullPath: ["x"], + pathWithoutLast: [], + pathLast: "x", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: -1, + }, + { + name: "y", + fullPath: ["y"], + pathWithoutLast: [], + pathLast: "y", + generics: [], + typeFilter: -1, + }, + ], + foundElems: 2, + original: "p<x> , y", + returned: [], + userQuery: "p<x> , y", + error: null, + }, + { + query: "p<x , y>", + elems: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [ + { + name: "x", + fullPath: ["x"], + pathWithoutLast: [], + pathLast: "x", + generics: [], + typeFilter: -1, + }, + { + name: "y", + fullPath: ["y"], + pathWithoutLast: [], + pathLast: "y", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: "p<x , y>", + returned: [], + userQuery: "p<x , y>", + error: null, + }, + { + query: "p ,x , y", + elems: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + typeFilter: -1, + }, + { + name: "x", + fullPath: ["x"], + pathWithoutLast: [], + pathLast: "x", + generics: [], + typeFilter: -1, + }, + { + name: "y", + fullPath: ["y"], + pathWithoutLast: [], + pathLast: "y", + generics: [], + typeFilter: -1, + }, + ], + foundElems: 3, + original: "p ,x , y", + returned: [], + userQuery: "p ,x , y", + error: null, + }, +]; diff --git a/tests/rustdoc-js-std/parser-filter.js b/tests/rustdoc-js-std/parser-filter.js new file mode 100644 index 00000000000..a1dd0ea3b5a --- /dev/null +++ b/tests/rustdoc-js-std/parser-filter.js @@ -0,0 +1,165 @@ +const PARSED = [ + { + query: 'fn:foo', + elems: [{ + name: "foo", + fullPath: ["foo"], + pathWithoutLast: [], + pathLast: "foo", + generics: [], + typeFilter: 7, + }], + foundElems: 1, + original: "fn:foo", + returned: [], + userQuery: "fn:foo", + error: null, + }, + { + query: 'enum : foo', + elems: [{ + name: "foo", + fullPath: ["foo"], + pathWithoutLast: [], + pathLast: "foo", + generics: [], + typeFilter: 6, + }], + foundElems: 1, + original: "enum : foo", + returned: [], + userQuery: "enum : foo", + error: null, + }, + { + query: 'macro<f>:foo', + elems: [], + foundElems: 0, + original: "macro<f>:foo", + returned: [], + userQuery: "macro<f>:foo", + error: "Unexpected `<` in type filter (before `:`)", + }, + { + query: 'macro!', + elems: [{ + name: "macro", + fullPath: ["macro"], + pathWithoutLast: [], + pathLast: "macro", + generics: [], + typeFilter: 16, + }], + foundElems: 1, + original: "macro!", + returned: [], + userQuery: "macro!", + error: null, + }, + { + query: 'macro:mac!', + elems: [{ + name: "mac", + fullPath: ["mac"], + pathWithoutLast: [], + pathLast: "mac", + generics: [], + typeFilter: 16, + }], + foundElems: 1, + original: "macro:mac!", + returned: [], + userQuery: "macro:mac!", + error: null, + }, + { + query: 'a::mac!', + elems: [{ + name: "a::mac", + fullPath: ["a", "mac"], + pathWithoutLast: ["a"], + pathLast: "mac", + generics: [], + typeFilter: 16, + }], + foundElems: 1, + original: "a::mac!", + returned: [], + userQuery: "a::mac!", + error: null, + }, + { + query: '-> fn:foo', + elems: [], + foundElems: 1, + original: "-> fn:foo", + returned: [{ + name: "foo", + fullPath: ["foo"], + pathWithoutLast: [], + pathLast: "foo", + generics: [], + typeFilter: 7, + }], + userQuery: "-> fn:foo", + error: null, + }, + { + query: '-> fn:foo<fn:bar>', + elems: [], + foundElems: 1, + original: "-> fn:foo<fn:bar>", + returned: [{ + name: "foo", + fullPath: ["foo"], + pathWithoutLast: [], + pathLast: "foo", + generics: [ + { + name: "bar", + fullPath: ["bar"], + pathWithoutLast: [], + pathLast: "bar", + generics: [], + typeFilter: 7, + } + ], + typeFilter: 7, + }], + userQuery: "-> fn:foo<fn:bar>", + error: null, + }, + { + query: '-> fn:foo<fn:bar, enum : baz::fuzz>', + elems: [], + foundElems: 1, + original: "-> fn:foo<fn:bar, enum : baz::fuzz>", + returned: [{ + name: "foo", + fullPath: ["foo"], + pathWithoutLast: [], + pathLast: "foo", + generics: [ + { + name: "bar", + fullPath: ["bar"], + pathWithoutLast: [], + pathLast: "bar", + generics: [], + typeFilter: 7, + }, + { + name: "baz::fuzz", + fullPath: ["baz", "fuzz"], + pathWithoutLast: ["baz"], + pathLast: "fuzz", + generics: [], + typeFilter: 6, + }, + ], + typeFilter: 7, + }], + userQuery: "-> fn:foo<fn:bar, enum : baz::fuzz>", + error: null, + }, +]; diff --git a/tests/rustdoc-js-std/parser-generics.js b/tests/rustdoc-js-std/parser-generics.js new file mode 100644 index 00000000000..726ee56c2c1 --- /dev/null +++ b/tests/rustdoc-js-std/parser-generics.js @@ -0,0 +1,179 @@ +const PARSED = [ + { + query: 'A<B<C<D>, E>', + elems: [], + foundElems: 0, + original: 'A<B<C<D>, E>', + returned: [], + userQuery: 'a<b<c<d>, e>', + error: 'Unclosed `<`', + }, + { + query: 'p<>,u8', + elems: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + typeFilter: -1, + }, + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + foundElems: 2, + original: "p<>,u8", + returned: [], + userQuery: "p<>,u8", + error: null, + }, + { + query: '"p"<a>', + elems: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [ + { + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + }, + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: '"p"<a>', + returned: [], + userQuery: '"p"<a>', + error: null, + }, + { + query: 'p<u<x>>', + elems: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [ + { + name: "u", + fullPath: ["u"], + pathWithoutLast: [], + pathLast: "u", + generics: [ + { + name: "x", + fullPath: ["x"], + pathWithoutLast: [], + pathLast: "x", + generics: [], + }, + ], + }, + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: 'p<u<x>>', + returned: [], + userQuery: 'p<u<x>>', + error: null, + }, + { + query: 'p<u<x>, r>', + elems: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [ + { + name: "u", + fullPath: ["u"], + pathWithoutLast: [], + pathLast: "u", + generics: [ + { + name: "x", + fullPath: ["x"], + pathWithoutLast: [], + pathLast: "x", + generics: [], + }, + ], + }, + { + name: "r", + fullPath: ["r"], + pathWithoutLast: [], + pathLast: "r", + generics: [], + }, + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: 'p<u<x>, r>', + returned: [], + userQuery: 'p<u<x>, r>', + error: null, + }, + { + query: 'p<u<x, r>>', + elems: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [ + { + name: "u", + fullPath: ["u"], + pathWithoutLast: [], + pathLast: "u", + generics: [ + { + name: "x", + fullPath: ["x"], + pathWithoutLast: [], + pathLast: "x", + generics: [], + }, + { + name: "r", + fullPath: ["r"], + pathWithoutLast: [], + pathLast: "r", + generics: [], + }, + ], + }, + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: 'p<u<x, r>>', + returned: [], + userQuery: 'p<u<x, r>>', + error: null, + }, +]; diff --git a/tests/rustdoc-js-std/parser-hof.js b/tests/rustdoc-js-std/parser-hof.js new file mode 100644 index 00000000000..0b99c45b7a9 --- /dev/null +++ b/tests/rustdoc-js-std/parser-hof.js @@ -0,0 +1,712 @@ +const PARSED = [ + // ML-style HOF + { + query: "(-> F<P>)", + elems: [{ + name: "->", + fullPath: ["->"], + pathWithoutLast: [], + pathLast: "->", + generics: [], + bindings: [ + [ + "output", + [{ + name: "f", + fullPath: ["f"], + pathWithoutLast: [], + pathLast: "f", + generics: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + }, + ], + typeFilter: -1, + }], + ], + ], + typeFilter: -1, + }], + foundElems: 1, + original: "(-> F<P>)", + returned: [], + userQuery: "(-> f<p>)", + error: null, + }, + { + query: "(-> P)", + elems: [{ + name: "->", + fullPath: ["->"], + pathWithoutLast: [], + pathLast: "->", + generics: [], + bindings: [ + [ + "output", + [{ + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + typeFilter: -1, + }], + ], + ], + typeFilter: -1, + }], + foundElems: 1, + original: "(-> P)", + returned: [], + userQuery: "(-> p)", + error: null, + }, + { + query: "(->,a)", + elems: [{ + name: "->", + fullPath: ["->"], + pathWithoutLast: [], + pathLast: "->", + generics: [], + bindings: [ + [ + "output", + [{ + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + ], + ], + typeFilter: -1, + }], + foundElems: 1, + original: "(->,a)", + returned: [], + userQuery: "(->,a)", + error: null, + }, + { + query: "(F<P> ->)", + elems: [{ + name: "->", + fullPath: ["->"], + pathWithoutLast: [], + pathLast: "->", + generics: [{ + name: "f", + fullPath: ["f"], + pathWithoutLast: [], + pathLast: "f", + generics: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + }, + ], + typeFilter: -1, + }], + bindings: [ + [ + "output", + [], + ], + ], + typeFilter: -1, + }], + foundElems: 1, + original: "(F<P> ->)", + returned: [], + userQuery: "(f<p> ->)", + error: null, + }, + { + query: "(P ->)", + elems: [{ + name: "->", + fullPath: ["->"], + pathWithoutLast: [], + pathLast: "->", + generics: [{ + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + typeFilter: -1, + }], + bindings: [ + [ + "output", + [], + ], + ], + typeFilter: -1, + }], + foundElems: 1, + original: "(P ->)", + returned: [], + userQuery: "(p ->)", + error: null, + }, + { + query: "(,a->)", + elems: [{ + name: "->", + fullPath: ["->"], + pathWithoutLast: [], + pathLast: "->", + generics: [{ + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + bindings: [ + [ + "output", + [], + ], + ], + typeFilter: -1, + }], + foundElems: 1, + original: "(,a->)", + returned: [], + userQuery: "(,a->)", + error: null, + }, + { + query: "(aaaaa->a)", + elems: [{ + name: "->", + fullPath: ["->"], + pathWithoutLast: [], + pathLast: "->", + generics: [{ + name: "aaaaa", + fullPath: ["aaaaa"], + pathWithoutLast: [], + pathLast: "aaaaa", + generics: [], + typeFilter: -1, + }], + bindings: [ + [ + "output", + [{ + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + ], + ], + typeFilter: -1, + }], + foundElems: 1, + original: "(aaaaa->a)", + returned: [], + userQuery: "(aaaaa->a)", + error: null, + }, + { + query: "(aaaaa, b -> a)", + elems: [{ + name: "->", + fullPath: ["->"], + pathWithoutLast: [], + pathLast: "->", + generics: [ + { + name: "aaaaa", + fullPath: ["aaaaa"], + pathWithoutLast: [], + pathLast: "aaaaa", + generics: [], + typeFilter: -1, + }, + { + name: "b", + fullPath: ["b"], + pathWithoutLast: [], + pathLast: "b", + generics: [], + typeFilter: -1, + }, + ], + bindings: [ + [ + "output", + [{ + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + ], + ], + typeFilter: -1, + }], + foundElems: 1, + original: "(aaaaa, b -> a)", + returned: [], + userQuery: "(aaaaa, b -> a)", + error: null, + }, + { + query: "primitive:(aaaaa, b -> a)", + elems: [{ + name: "->", + fullPath: ["->"], + pathWithoutLast: [], + pathLast: "->", + generics: [ + { + name: "aaaaa", + fullPath: ["aaaaa"], + pathWithoutLast: [], + pathLast: "aaaaa", + generics: [], + typeFilter: -1, + }, + { + name: "b", + fullPath: ["b"], + pathWithoutLast: [], + pathLast: "b", + generics: [], + typeFilter: -1, + }, + ], + bindings: [ + [ + "output", + [{ + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + ], + ], + typeFilter: 1, + }], + foundElems: 1, + original: "primitive:(aaaaa, b -> a)", + returned: [], + userQuery: "primitive:(aaaaa, b -> a)", + error: null, + }, + { + query: "x, trait:(aaaaa, b -> a)", + elems: [ + { + name: "x", + fullPath: ["x"], + pathWithoutLast: [], + pathLast: "x", + generics: [], + typeFilter: -1, + }, + { + name: "->", + fullPath: ["->"], + pathWithoutLast: [], + pathLast: "->", + generics: [ + { + name: "aaaaa", + fullPath: ["aaaaa"], + pathWithoutLast: [], + pathLast: "aaaaa", + generics: [], + typeFilter: -1, + }, + { + name: "b", + fullPath: ["b"], + pathWithoutLast: [], + pathLast: "b", + generics: [], + typeFilter: -1, + }, + ], + bindings: [ + [ + "output", + [{ + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + ], + ], + typeFilter: 10, + } + ], + foundElems: 2, + original: "x, trait:(aaaaa, b -> a)", + returned: [], + userQuery: "x, trait:(aaaaa, b -> a)", + error: null, + }, + // Rust-style HOF + { + query: "Fn () -> F<P>", + elems: [{ + name: "fn", + fullPath: ["fn"], + pathWithoutLast: [], + pathLast: "fn", + generics: [], + bindings: [ + [ + "output", + [{ + name: "f", + fullPath: ["f"], + pathWithoutLast: [], + pathLast: "f", + generics: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + }, + ], + typeFilter: -1, + }], + ], + ], + typeFilter: -1, + }], + foundElems: 1, + original: "Fn () -> F<P>", + returned: [], + userQuery: "fn () -> f<p>", + error: null, + }, + { + query: "FnMut() -> P", + elems: [{ + name: "fnmut", + fullPath: ["fnmut"], + pathWithoutLast: [], + pathLast: "fnmut", + generics: [], + bindings: [ + [ + "output", + [{ + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + typeFilter: -1, + }], + ], + ], + typeFilter: -1, + }], + foundElems: 1, + original: "FnMut() -> P", + returned: [], + userQuery: "fnmut() -> p", + error: null, + }, + { + query: "(FnMut() -> P)", + elems: [{ + name: "fnmut", + fullPath: ["fnmut"], + pathWithoutLast: [], + pathLast: "fnmut", + generics: [], + bindings: [ + [ + "output", + [{ + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + typeFilter: -1, + }], + ], + ], + typeFilter: -1, + }], + foundElems: 1, + original: "(FnMut() -> P)", + returned: [], + userQuery: "(fnmut() -> p)", + error: null, + }, + { + query: "Fn(F<P>)", + elems: [{ + name: "fn", + fullPath: ["fn"], + pathWithoutLast: [], + pathLast: "fn", + generics: [{ + name: "f", + fullPath: ["f"], + pathWithoutLast: [], + pathLast: "f", + generics: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + }, + ], + typeFilter: -1, + }], + bindings: [ + [ + "output", + [], + ], + ], + typeFilter: -1, + }], + foundElems: 1, + original: "Fn(F<P>)", + returned: [], + userQuery: "fn(f<p>)", + error: null, + }, + { + query: "primitive:fnonce(aaaaa, b) -> a", + elems: [{ + name: "fnonce", + fullPath: ["fnonce"], + pathWithoutLast: [], + pathLast: "fnonce", + generics: [ + { + name: "aaaaa", + fullPath: ["aaaaa"], + pathWithoutLast: [], + pathLast: "aaaaa", + generics: [], + typeFilter: -1, + }, + { + name: "b", + fullPath: ["b"], + pathWithoutLast: [], + pathLast: "b", + generics: [], + typeFilter: -1, + }, + ], + bindings: [ + [ + "output", + [{ + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + ], + ], + typeFilter: 1, + }], + foundElems: 1, + original: "primitive:fnonce(aaaaa, b) -> a", + returned: [], + userQuery: "primitive:fnonce(aaaaa, b) -> a", + error: null, + }, + { + query: "primitive:fnonce(aaaaa, keyword:b) -> trait:a", + elems: [{ + name: "fnonce", + fullPath: ["fnonce"], + pathWithoutLast: [], + pathLast: "fnonce", + generics: [ + { + name: "aaaaa", + fullPath: ["aaaaa"], + pathWithoutLast: [], + pathLast: "aaaaa", + generics: [], + typeFilter: -1, + }, + { + name: "b", + fullPath: ["b"], + pathWithoutLast: [], + pathLast: "b", + generics: [], + typeFilter: 0, + }, + ], + bindings: [ + [ + "output", + [{ + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: 10, + }], + ], + ], + typeFilter: 1, + }], + foundElems: 1, + original: "primitive:fnonce(aaaaa, keyword:b) -> trait:a", + returned: [], + userQuery: "primitive:fnonce(aaaaa, keyword:b) -> trait:a", + error: null, + }, + { + query: "x, trait:fn(aaaaa, b -> a)", + elems: [ + { + name: "x", + fullPath: ["x"], + pathWithoutLast: [], + pathLast: "x", + generics: [], + typeFilter: -1, + }, + { + name: "fn", + fullPath: ["fn"], + pathWithoutLast: [], + pathLast: "fn", + generics: [ + { + name: "->", + fullPath: ["->"], + pathWithoutLast: [], + pathLast: "->", + generics: [ + { + name: "aaaaa", + fullPath: ["aaaaa"], + pathWithoutLast: [], + pathLast: "aaaaa", + generics: [], + typeFilter: -1, + }, + { + name: "b", + fullPath: ["b"], + pathWithoutLast: [], + pathLast: "b", + generics: [], + typeFilter: -1, + }, + ], + bindings: [ + [ + "output", + [{ + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + ], + ], + typeFilter: -1, + }, + ], + bindings: [ + [ + "output", + [], + ] + ], + typeFilter: 10, + } + ], + foundElems: 2, + original: "x, trait:fn(aaaaa, b -> a)", + returned: [], + userQuery: "x, trait:fn(aaaaa, b -> a)", + error: null, + }, + { + query: 'a,b(c)', + elems: [ + { + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: -1, + }, + { + name: "b", + fullPath: ["b"], + pathWithoutLast: [], + pathLast: "b", + generics: [{ + name: "c", + fullPath: ["c"], + pathWithoutLast: [], + pathLast: "c", + generics: [], + typeFilter: -1, + }], + bindings: [ + [ + "output", + [], + ] + ], + typeFilter: -1, + } + ], + foundElems: 2, + original: "a,b(c)", + returned: [], + userQuery: "a,b(c)", + error: null, + }, +]; diff --git a/tests/rustdoc-js-std/parser-ident.js b/tests/rustdoc-js-std/parser-ident.js new file mode 100644 index 00000000000..cc79c58f1da --- /dev/null +++ b/tests/rustdoc-js-std/parser-ident.js @@ -0,0 +1,154 @@ +const PARSED = [ + { + query: "R<!>", + elems: [{ + name: "r", + fullPath: ["r"], + pathWithoutLast: [], + pathLast: "r", + generics: [ + { + name: "never", + fullPath: ["never"], + pathWithoutLast: [], + pathLast: "never", + generics: [], + typeFilter: 1, + }, + ], + typeFilter: -1, + }], + foundElems: 1, + original: "R<!>", + returned: [], + userQuery: "r<!>", + error: null, + }, + { + query: "!", + elems: [{ + name: "never", + fullPath: ["never"], + pathWithoutLast: [], + pathLast: "never", + generics: [], + typeFilter: 1, + }], + foundElems: 1, + original: "!", + returned: [], + userQuery: "!", + error: null, + }, + { + query: "a!", + elems: [{ + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: 16, + }], + foundElems: 1, + original: "a!", + returned: [], + userQuery: "a!", + error: null, + }, + { + query: "a!::b", + elems: [], + foundElems: 0, + original: "a!::b", + returned: [], + userQuery: "a!::b", + error: "Cannot have associated items in macros", + }, + { + query: "!<T>", + elems: [], + foundElems: 0, + original: "!<T>", + returned: [], + userQuery: "!<t>", + error: "Never type `!` does not accept generic parameters", + }, + { + query: "!::b", + elems: [{ + name: "!::b", + fullPath: ["never", "b"], + pathWithoutLast: ["never"], + pathLast: "b", + generics: [], + typeFilter: -1, + }], + foundElems: 1, + original: "!::b", + returned: [], + userQuery: "!::b", + error: null, + }, + { + query: "b::!", + elems: [], + foundElems: 0, + original: "b::!", + returned: [], + userQuery: "b::!", + error: "Never type `!` is not associated item", + }, + { + query: "!::!", + elems: [], + foundElems: 0, + original: "!::!", + returned: [], + userQuery: "!::!", + error: "Never type `!` is not associated item", + }, + { + query: "b::!::c", + elems: [], + foundElems: 0, + original: "b::!::c", + returned: [], + userQuery: "b::!::c", + error: "Never type `!` is not associated item", + }, + { + query: "!::b<T>", + elems: [{ + name: "!::b", + fullPath: ["never", "b"], + pathWithoutLast: ["never"], + pathLast: "b", + generics: [ + { + name: "t", + fullPath: ["t"], + pathWithoutLast: [], + pathLast: "t", + generics: [], + typeFilter: -1, + } + ], + typeFilter: -1, + }], + foundElems: 1, + original: "!::b<T>", + returned: [], + userQuery: "!::b<t>", + error: null, + }, + { + query: "a!::b!", + elems: [], + foundElems: 0, + original: "a!::b!", + returned: [], + userQuery: "a!::b!", + error: "Cannot have associated items in macros", + }, +]; diff --git a/tests/rustdoc-js-std/parser-literal.js b/tests/rustdoc-js-std/parser-literal.js new file mode 100644 index 00000000000..87c06224dbf --- /dev/null +++ b/tests/rustdoc-js-std/parser-literal.js @@ -0,0 +1,26 @@ +const PARSED = [ + { + query: 'R<P>', + elems: [{ + name: "r", + fullPath: ["r"], + pathWithoutLast: [], + pathLast: "r", + generics: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + }, + ], + typeFilter: -1, + }], + foundElems: 1, + original: "R<P>", + returned: [], + userQuery: "r<p>", + error: null, + } +]; diff --git a/tests/rustdoc-js-std/parser-paths.js b/tests/rustdoc-js-std/parser-paths.js new file mode 100644 index 00000000000..774e5d028cc --- /dev/null +++ b/tests/rustdoc-js-std/parser-paths.js @@ -0,0 +1,142 @@ +const PARSED = [ + { + query: 'A::B', + elems: [{ + name: "a::b", + fullPath: ["a", "b"], + pathWithoutLast: ["a"], + pathLast: "b", + generics: [], + typeFilter: -1, + }], + foundElems: 1, + original: "A::B", + returned: [], + userQuery: "a::b", + error: null, + }, + { + query: "a:: a", + elems: [{ + name: "a:: a", + fullPath: ["a", "a"], + pathWithoutLast: ["a"], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + foundElems: 1, + original: 'a:: a', + returned: [], + userQuery: 'a:: a', + error: null, + }, + { + query: "a ::a", + elems: [{ + name: "a ::a", + fullPath: ["a", "a"], + pathWithoutLast: ["a"], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + foundElems: 1, + original: 'a ::a', + returned: [], + userQuery: 'a ::a', + error: null, + }, + { + query: "a :: a", + elems: [{ + name: "a :: a", + fullPath: ["a", "a"], + pathWithoutLast: ["a"], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + foundElems: 1, + original: 'a :: a', + returned: [], + userQuery: 'a :: a', + error: null, + }, + { + query: 'A::B,C', + elems: [ + { + name: "a::b", + fullPath: ["a", "b"], + pathWithoutLast: ["a"], + pathLast: "b", + generics: [], + typeFilter: -1, + }, + { + name: "c", + fullPath: ["c"], + pathWithoutLast: [], + pathLast: "c", + generics: [], + typeFilter: -1, + }, + ], + foundElems: 2, + original: 'A::B,C', + returned: [], + userQuery: 'a::b,c', + error: null, + }, + { + query: 'A::B<f>,C', + elems: [ + { + name: "a::b", + fullPath: ["a", "b"], + pathWithoutLast: ["a"], + pathLast: "b", + generics: [ + { + name: "f", + fullPath: ["f"], + pathWithoutLast: [], + pathLast: "f", + generics: [], + }, + ], + typeFilter: -1, + }, + { + name: "c", + fullPath: ["c"], + pathWithoutLast: [], + pathLast: "c", + generics: [], + typeFilter: -1, + }, + ], + foundElems: 2, + original: 'A::B<f>,C', + returned: [], + userQuery: 'a::b<f>,c', + error: null, + }, + { + query: 'mod::a', + elems: [{ + name: "mod::a", + fullPath: ["mod", "a"], + pathWithoutLast: ["mod"], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + foundElems: 1, + original: "mod::a", + returned: [], + userQuery: "mod::a", + error: null, + }, +]; diff --git a/tests/rustdoc-js-std/parser-quote.js b/tests/rustdoc-js-std/parser-quote.js new file mode 100644 index 00000000000..731673cf463 --- /dev/null +++ b/tests/rustdoc-js-std/parser-quote.js @@ -0,0 +1,79 @@ +const PARSED = [ + { + query: '-> "p"', + elems: [], + foundElems: 1, + original: '-> "p"', + returned: [{ + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + typeFilter: -1, + }], + userQuery: '-> "p"', + error: null, + }, + { + query: '"p",', + elems: [{ + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + typeFilter: -1, + }], + foundElems: 1, + original: '"p",', + returned: [], + userQuery: '"p",', + error: null, + }, + { + query: '"p" -> a', + elems: [], + foundElems: 0, + original: '"p" -> a', + returned: [], + userQuery: '"p" -> a', + error: "Cannot have more than one element if you use quotes", + }, + { + query: '"a" -> "p"', + elems: [], + foundElems: 0, + original: '"a" -> "p"', + returned: [], + userQuery: '"a" -> "p"', + error: "Cannot have more than one literal search element", + }, + { + query: '->"-"', + elems: [], + foundElems: 0, + original: '->"-"', + returned: [], + userQuery: '->"-"', + error: 'Unexpected `-` in a string element', + }, + { + query: '"a', + elems: [], + foundElems: 0, + original: '"a', + returned: [], + userQuery: '"a', + error: 'Unclosed `"`', + }, + { + query: '""', + elems: [], + foundElems: 0, + original: '""', + returned: [], + userQuery: '""', + error: 'Cannot have empty string element', + }, +]; diff --git a/tests/rustdoc-js-std/parser-reference.js b/tests/rustdoc-js-std/parser-reference.js new file mode 100644 index 00000000000..6b1250146be --- /dev/null +++ b/tests/rustdoc-js-std/parser-reference.js @@ -0,0 +1,527 @@ +const PARSED = [ + { + query: '&[', + elems: [], + foundElems: 0, + original: '&[', + returned: [], + userQuery: '&[', + error: 'Unclosed `[`', + }, + { + query: '[&', + elems: [], + foundElems: 0, + original: '[&', + returned: [], + userQuery: '[&', + error: 'Unclosed `[`', + }, + { + query: '&&&D, []', + elems: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "d", + fullPath: ["d"], + pathWithoutLast: [], + pathLast: "d", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + ], + typeFilter: 1, + }, + ], + typeFilter: 1, + }, + { + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [], + typeFilter: 1, + }, + ], + foundElems: 2, + original: '&&&D, []', + returned: [], + userQuery: '&&&d, []', + error: null, + }, + { + query: '&&&[D]', + elems: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [ + { + name: "d", + fullPath: ["d"], + pathWithoutLast: [], + pathLast: "d", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + ], + typeFilter: 1, + }, + ], + typeFilter: 1, + }, + ], + typeFilter: 1, + }, + ], + foundElems: 1, + original: '&&&[D]', + returned: [], + userQuery: '&&&[d]', + error: null, + }, + { + query: '&', + elems: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [], + typeFilter: 1, + }, + ], + foundElems: 1, + original: '&', + returned: [], + userQuery: '&', + error: null, + }, + { + query: '&mut', + elems: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "mut", + fullPath: ["mut"], + pathWithoutLast: [], + pathLast: "mut", + generics: [], + typeFilter: 0, + }, + ], + typeFilter: 1, + }, + ], + foundElems: 1, + original: '&mut', + returned: [], + userQuery: '&mut', + error: null, + }, + { + query: '&,u8', + elems: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [], + typeFilter: 1, + }, + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + foundElems: 2, + original: "&,u8", + returned: [], + userQuery: "&,u8", + error: null, + }, + { + query: '&mut,u8', + elems: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "mut", + fullPath: ["mut"], + pathWithoutLast: [], + pathLast: "mut", + generics: [], + typeFilter: 0, + }, + ], + typeFilter: 1, + }, + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + foundElems: 2, + original: "&mut,u8", + returned: [], + userQuery: "&mut,u8", + error: null, + }, + { + query: '&u8', + elems: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + ], + foundElems: 1, + original: "&u8", + returned: [], + userQuery: "&u8", + error: null, + }, + { + query: '&u8<u8>', + elems: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + ], + foundElems: 1, + original: "&u8<u8>", + returned: [], + userQuery: "&u8<u8>", + error: null, + }, + { + query: 'u8<&u8>', + elems: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: "u8<&u8>", + returned: [], + userQuery: "u8<&u8>", + error: null, + }, + { + query: 'u8<&u8, u8>', + elems: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: "u8<&u8, u8>", + returned: [], + userQuery: "u8<&u8, u8>", + error: null, + }, + { + query: 'u8<&u8>', + elems: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: "u8<&u8>", + returned: [], + userQuery: "u8<&u8>", + error: null, + }, + { + query: 'u8<&mut u8, u8>', + elems: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "mut", + fullPath: ["mut"], + pathWithoutLast: [], + pathLast: "mut", + generics: [], + typeFilter: 0, + }, + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: "u8<&mut u8, u8>", + returned: [], + userQuery: "u8<&mut u8, u8>", + error: null, + }, + { + query: 'primitive:&u8', + elems: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + ], + foundElems: 1, + original: "primitive:&u8", + returned: [], + userQuery: "primitive:&u8", + error: null, + }, + { + query: 'macro:&u8', + elems: [], + foundElems: 0, + original: "macro:&u8", + returned: [], + userQuery: "macro:&u8", + error: "Invalid search type: primitive `&` and `macro` both specified", + }, + { + query: '¯o:u8', + elems: [ + { + name: "reference", + fullPath: ["reference"], + pathWithoutLast: [], + pathLast: "reference", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: 16, + }, + ], + typeFilter: 1, + }, + ], + foundElems: 1, + original: "¯o:u8", + returned: [], + userQuery: "¯o:u8", + error: null, + }, +]; diff --git a/tests/rustdoc-js-std/parser-returned.js b/tests/rustdoc-js-std/parser-returned.js new file mode 100644 index 00000000000..44e517c49b5 --- /dev/null +++ b/tests/rustdoc-js-std/parser-returned.js @@ -0,0 +1,97 @@ +const PARSED = [ + { + query: "-> F<P>", + elems: [], + foundElems: 1, + original: "-> F<P>", + returned: [{ + name: "f", + fullPath: ["f"], + pathWithoutLast: [], + pathLast: "f", + generics: [ + { + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + }, + ], + typeFilter: -1, + }], + userQuery: "-> f<p>", + error: null, + }, + { + query: "-> P", + elems: [], + foundElems: 1, + original: "-> P", + returned: [{ + name: "p", + fullPath: ["p"], + pathWithoutLast: [], + pathLast: "p", + generics: [], + typeFilter: -1, + }], + userQuery: "-> p", + error: null, + }, + { + query: "->,a", + elems: [], + foundElems: 1, + original: "->,a", + returned: [{ + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + userQuery: "->,a", + error: null, + }, + { + query: "aaaaa->a", + elems: [{ + name: "aaaaa", + fullPath: ["aaaaa"], + pathWithoutLast: [], + pathLast: "aaaaa", + generics: [], + typeFilter: -1, + }], + foundElems: 2, + original: "aaaaa->a", + returned: [{ + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + typeFilter: -1, + }], + userQuery: "aaaaa->a", + error: null, + }, + { + query: "-> !", + elems: [], + foundElems: 1, + original: "-> !", + returned: [{ + name: "never", + fullPath: ["never"], + pathWithoutLast: [], + pathLast: "never", + generics: [], + typeFilter: 1, + }], + userQuery: "-> !", + error: null, + }, +]; diff --git a/tests/rustdoc-js-std/parser-separators.js b/tests/rustdoc-js-std/parser-separators.js new file mode 100644 index 00000000000..7f95f61b006 --- /dev/null +++ b/tests/rustdoc-js-std/parser-separators.js @@ -0,0 +1,195 @@ +// ignore-tidy-tab + +const PARSED = [ + { + query: 'aaaaaa b', + elems: [ + { + name: 'aaaaaa b', + fullPath: ['aaaaaa', 'b'], + pathWithoutLast: ['aaaaaa'], + pathLast: 'b', + generics: [], + typeFilter: -1, + }, + ], + foundElems: 1, + original: "aaaaaa b", + returned: [], + userQuery: "aaaaaa b", + error: null, + }, + { + query: "aaaaaa, b", + elems: [ + { + name: 'aaaaaa', + fullPath: ['aaaaaa'], + pathWithoutLast: [], + pathLast: 'aaaaaa', + generics: [], + typeFilter: -1, + }, + { + name: 'b', + fullPath: ['b'], + pathWithoutLast: [], + pathLast: 'b', + generics: [], + typeFilter: -1, + }, + ], + foundElems: 2, + original: "aaaaaa, b", + returned: [], + userQuery: "aaaaaa, b", + error: null, + }, + { + query: 'a b', + elems: [ + { + name: 'a b', + fullPath: ['a', 'b'], + pathWithoutLast: ['a'], + pathLast: 'b', + generics: [], + typeFilter: -1, + }, + ], + foundElems: 1, + original: "a b", + returned: [], + userQuery: "a b", + error: null, + }, + { + query: 'a,b', + elems: [ + { + name: 'a', + fullPath: ['a'], + pathWithoutLast: [], + pathLast: 'a', + generics: [], + typeFilter: -1, + }, + { + name: 'b', + fullPath: ['b'], + pathWithoutLast: [], + pathLast: 'b', + generics: [], + typeFilter: -1, + }, + ], + foundElems: 2, + original: "a,b", + returned: [], + userQuery: "a,b", + error: null, + }, + { + query: 'a\tb', + elems: [ + { + name: 'a b', + fullPath: ['a', 'b'], + pathWithoutLast: ['a'], + pathLast: 'b', + generics: [], + typeFilter: -1, + }, + ], + foundElems: 1, + original: "a b", + returned: [], + userQuery: "a b", + error: null, + }, + { + query: 'a<b c>', + elems: [ + { + name: 'a', + fullPath: ['a'], + pathWithoutLast: [], + pathLast: 'a', + generics: [ + { + name: 'b c', + fullPath: ['b', 'c'], + pathWithoutLast: ['b'], + pathLast: 'c', + generics: [], + }, + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: "a<b c>", + returned: [], + userQuery: "a<b c>", + error: null, + }, + { + query: 'a<b,c>', + elems: [ + { + name: 'a', + fullPath: ['a'], + pathWithoutLast: [], + pathLast: 'a', + generics: [ + { + name: 'b', + fullPath: ['b'], + pathWithoutLast: [], + pathLast: 'b', + generics: [], + }, + { + name: 'c', + fullPath: ['c'], + pathWithoutLast: [], + pathLast: 'c', + generics: [], + }, + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: "a<b,c>", + returned: [], + userQuery: "a<b,c>", + error: null, + }, + { + query: 'a<b\tc>', + elems: [ + { + name: 'a', + fullPath: ['a'], + pathWithoutLast: [], + pathLast: 'a', + generics: [ + { + name: 'b c', + fullPath: ['b', 'c'], + pathWithoutLast: ['b'], + pathLast: 'c', + generics: [], + }, + ], + typeFilter: -1, + }, + ], + foundElems: 1, + original: "a<b c>", + returned: [], + userQuery: "a<b c>", + error: null, + }, +]; diff --git a/tests/rustdoc-js-std/parser-slice-array.js b/tests/rustdoc-js-std/parser-slice-array.js new file mode 100644 index 00000000000..1de52af94e6 --- /dev/null +++ b/tests/rustdoc-js-std/parser-slice-array.js @@ -0,0 +1,323 @@ +const PARSED = [ + { + query: '[[[D, []]]', + elems: [], + foundElems: 0, + original: '[[[D, []]]', + returned: [], + userQuery: '[[[d, []]]', + error: 'Unclosed `[`', + }, + { + query: '[[[D, []]]]', + elems: [ + { + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [ + { + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [ + { + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [ + { + name: "d", + fullPath: ["d"], + pathWithoutLast: [], + pathLast: "d", + generics: [], + typeFilter: -1, + }, + { + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [], + typeFilter: 1, + }, + ], + typeFilter: 1, + }, + ], + typeFilter: 1, + }, + ], + typeFilter: 1, + }, + ], + foundElems: 1, + original: '[[[D, []]]]', + returned: [], + userQuery: '[[[d, []]]]', + error: null, + }, + { + query: '[],u8', + elems: [ + { + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [], + typeFilter: 1, + }, + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + foundElems: 2, + original: "[],u8", + returned: [], + userQuery: "[],u8", + error: null, + }, + { + query: '[u8]', + elems: [ + { + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + ], + foundElems: 1, + original: "[u8]", + returned: [], + userQuery: "[u8]", + 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, + original: "[u8,u8]", + returned: [], + userQuery: "[u8,u8]", + error: null, + }, + { + query: '[u8<u8>]', + elems: [ + { + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + ], + foundElems: 1, + original: "[u8<u8>]", + returned: [], + userQuery: "[u8<u8>]", + error: null, + }, + { + query: '[]', + elems: [ + { + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [], + typeFilter: 1, + }, + ], + foundElems: 1, + original: "[]", + returned: [], + userQuery: "[]", + error: null, + }, + { + query: '[>', + elems: [], + foundElems: 0, + original: "[>", + returned: [], + userQuery: "[>", + error: "Unexpected `>` after `[`", + }, + { + query: '[<', + elems: [], + foundElems: 0, + original: "[<", + returned: [], + userQuery: "[<", + error: "Found generics without a path", + }, + { + query: '[a>', + elems: [], + foundElems: 0, + original: "[a>", + returned: [], + userQuery: "[a>", + error: "Unexpected `>` after `[`", + }, + { + query: '[a<', + elems: [], + foundElems: 0, + original: "[a<", + returned: [], + userQuery: "[a<", + error: "Unclosed `<`", + }, + { + query: '[a', + elems: [], + foundElems: 0, + original: "[a", + returned: [], + userQuery: "[a", + error: "Unclosed `[`", + }, + { + query: '[', + elems: [], + foundElems: 0, + original: "[", + returned: [], + userQuery: "[", + error: "Unclosed `[`", + }, + { + query: ']', + elems: [], + foundElems: 0, + original: "]", + returned: [], + userQuery: "]", + error: "Unexpected `]`", + }, + { + query: '[a<b>', + elems: [], + foundElems: 0, + original: "[a<b>", + returned: [], + userQuery: "[a<b>", + error: "Unclosed `[`", + }, + { + query: 'a<b>]', + elems: [], + foundElems: 0, + original: "a<b>]", + returned: [], + userQuery: "a<b>]", + error: "Unexpected `]` after `>`", + }, + { + query: 'primitive:[u8]', + elems: [ + { + name: "[]", + fullPath: ["[]"], + pathWithoutLast: [], + pathLast: "[]", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + ], + foundElems: 1, + original: "primitive:[u8]", + returned: [], + userQuery: "primitive:[u8]", + error: null, + }, + { + query: 'macro:[u8]', + elems: [], + foundElems: 0, + original: "macro:[u8]", + returned: [], + userQuery: "macro:[u8]", + error: "Invalid search type: primitive `[]` and `macro` both specified", + }, +]; diff --git a/tests/rustdoc-js-std/parser-tuple.js b/tests/rustdoc-js-std/parser-tuple.js new file mode 100644 index 00000000000..eb16289d3c0 --- /dev/null +++ b/tests/rustdoc-js-std/parser-tuple.js @@ -0,0 +1,365 @@ +const PARSED = [ + { + query: '(((D, ()))', + elems: [], + foundElems: 0, + original: '(((D, ()))', + returned: [], + userQuery: '(((d, ()))', + 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, + original: '(((D, ())))', + returned: [], + userQuery: '(((d, ())))', + error: null, + }, + { + query: '(),u8', + elems: [ + { + name: "()", + fullPath: ["()"], + pathWithoutLast: [], + pathLast: "()", + generics: [], + typeFilter: 1, + }, + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + foundElems: 2, + original: "(),u8", + returned: [], + userQuery: "(),u8", + 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, + original: "(u8)", + returned: [], + userQuery: "(u8)", + error: null, + }, + { + query: '(u8,)', + elems: [ + { + name: "()", + fullPath: ["()"], + pathWithoutLast: [], + pathLast: "()", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + ], + foundElems: 1, + original: "(u8,)", + returned: [], + userQuery: "(u8,)", + error: null, + }, + { + query: '(,u8)', + elems: [ + { + name: "()", + fullPath: ["()"], + pathWithoutLast: [], + pathLast: "()", + generics: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: -1, + }, + ], + typeFilter: 1, + }, + ], + foundElems: 1, + original: "(,u8)", + returned: [], + userQuery: "(,u8)", + 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, + original: "primitive:(u8)", + returned: [], + userQuery: "primitive:(u8)", + error: null, + }, + { + query: '(primitive:u8)', + elems: [ + { + name: "u8", + fullPath: ["u8"], + pathWithoutLast: [], + pathLast: "u8", + generics: [], + typeFilter: 1, + }, + ], + foundElems: 1, + original: "(primitive:u8)", + returned: [], + userQuery: "(primitive:u8)", + 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, + original: "(u8,u8)", + returned: [], + userQuery: "(u8,u8)", + 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, + original: "(u8<u8>)", + returned: [], + userQuery: "(u8<u8>)", + error: null, + }, + { + query: '()', + elems: [ + { + name: "()", + fullPath: ["()"], + pathWithoutLast: [], + pathLast: "()", + generics: [], + typeFilter: 1, + }, + ], + foundElems: 1, + original: "()", + returned: [], + userQuery: "()", + error: null, + }, + { + query: '(>', + elems: [], + foundElems: 0, + original: "(>", + returned: [], + userQuery: "(>", + error: "Unexpected `>` after `(`", + }, + { + query: '(<', + elems: [], + foundElems: 0, + original: "(<", + returned: [], + userQuery: "(<", + error: "Found generics without a path", + }, + { + query: '(a>', + elems: [], + foundElems: 0, + original: "(a>", + returned: [], + userQuery: "(a>", + error: "Unexpected `>` after `(`", + }, + { + query: '(a<', + elems: [], + foundElems: 0, + original: "(a<", + returned: [], + userQuery: "(a<", + error: "Unclosed `<`", + }, + { + query: '(a', + elems: [], + foundElems: 0, + original: "(a", + returned: [], + userQuery: "(a", + error: "Unclosed `(`", + }, + { + query: '(', + elems: [], + foundElems: 0, + original: "(", + returned: [], + userQuery: "(", + error: "Unclosed `(`", + }, + { + query: ')', + elems: [], + foundElems: 0, + original: ")", + returned: [], + userQuery: ")", + error: "Unexpected `)`", + }, + { + query: '(a<b>', + elems: [], + foundElems: 0, + original: "(a<b>", + returned: [], + userQuery: "(a<b>", + error: "Unclosed `(`", + }, + { + query: 'a<b>)', + elems: [], + foundElems: 0, + original: "a<b>)", + returned: [], + userQuery: "a<b>)", + error: "Unexpected `)` after `>`", + }, + { + query: 'macro:(u8)', + elems: [], + foundElems: 0, + original: "macro:(u8)", + returned: [], + userQuery: "macro:(u8)", + error: "Invalid search type: primitive `()` and `macro` both specified", + }, +]; diff --git a/tests/rustdoc-js-std/parser-weird-queries.js b/tests/rustdoc-js-std/parser-weird-queries.js new file mode 100644 index 00000000000..499b82a3469 --- /dev/null +++ b/tests/rustdoc-js-std/parser-weird-queries.js @@ -0,0 +1,91 @@ +// This test is mostly to check that the parser still kinda outputs something +// (and doesn't enter an infinite loop!) even though the query is completely +// invalid. + +const PARSED = [ + { + query: 'a b', + elems: [ + { + name: "a b", + fullPath: ["a", "b"], + pathWithoutLast: ["a"], + pathLast: "b", + generics: [], + }, + ], + foundElems: 1, + original: "a b", + returned: [], + userQuery: "a b", + error: null, + }, + { + query: 'a b', + elems: [ + { + name: "a b", + fullPath: ["a", "b"], + pathWithoutLast: ["a"], + pathLast: "b", + generics: [], + }, + ], + foundElems: 1, + original: "a b", + returned: [], + userQuery: "a b", + error: null, + }, + { + query: 'aaa,a', + elems: [ + { + name: "aaa", + fullPath: ["aaa"], + pathWithoutLast: [], + pathLast: "aaa", + generics: [], + }, + { + name: "a", + fullPath: ["a"], + pathWithoutLast: [], + pathLast: "a", + generics: [], + }, + ], + foundElems: 2, + original: "aaa,a", + returned: [], + userQuery: "aaa,a", + error: null, + }, + { + query: ',,,,', + elems: [], + foundElems: 0, + original: ",,,,", + returned: [], + userQuery: ",,,,", + error: null, + }, + { + query: 'mod :', + elems: [], + foundElems: 0, + original: 'mod :', + returned: [], + userQuery: 'mod :', + error: "Unexpected `:` (expected path after type filter `mod:`)", + }, + { + query: 'mod\t:', + elems: [], + foundElems: 0, + original: 'mod :', + returned: [], + userQuery: 'mod :', + error: "Unexpected `:` (expected path after type filter `mod:`)", + }, +]; diff --git a/tests/rustdoc-js-std/path-maxeditdistance.js b/tests/rustdoc-js-std/path-maxeditdistance.js new file mode 100644 index 00000000000..822389aaa4f --- /dev/null +++ b/tests/rustdoc-js-std/path-maxeditdistance.js @@ -0,0 +1,42 @@ +// exact-check +const FILTER_CRATE = "std"; +const EXPECTED = [ + { + query: 'vec::intoiterator', + others: [ + // trait std::iter::IntoIterator is not the first result + { 'path': 'std::vec', 'name': 'IntoIter' }, + { 'path': 'std::vec::Vec', 'name': 'into_iter' }, + { 'path': 'std::vec::Drain', 'name': 'into_iter' }, + { 'path': 'std::vec::IntoIter', 'name': 'into_iter' }, + { 'path': 'std::vec::ExtractIf', 'name': 'into_iter' }, + { 'path': 'std::vec::Splice', 'name': 'into_iter' }, + { 'path': 'std::collections::VecDeque', 'name': 'into_iter' }, + ], + }, + { + query: 'vec::iter', + others: [ + // std::net::ToSocketAttrs::iter should not show up here + { 'path': 'std::vec', 'name': 'IntoIter' }, + { 'path': 'std::vec::Vec', 'name': 'from_iter' }, + { 'path': 'std::vec::Vec', 'name': 'into_iter' }, + { 'path': 'std::vec::Drain', 'name': 'into_iter' }, + { 'path': 'std::vec::IntoIter', 'name': 'into_iter' }, + { 'path': 'std::vec::ExtractIf', 'name': 'into_iter' }, + { 'path': 'std::vec::Splice', 'name': 'into_iter' }, + { 'path': 'std::collections::VecDeque', 'name': 'iter' }, + { 'path': 'std::collections::VecDeque', 'name': 'iter_mut' }, + { 'path': 'std::collections::VecDeque', 'name': 'from_iter' }, + { 'path': 'std::collections::VecDeque', 'name': 'into_iter' }, + ], + }, + { + query: 'slice::itermut', + others: [ + // std::collections::btree_map::itermut should not show up here + { 'path': 'std::slice', 'name': 'IterMut' }, + { 'path': 'std::slice', 'name': 'iter_mut' }, + ], + }, +]; diff --git a/tests/rustdoc-js-std/path-ordering.js b/tests/rustdoc-js-std/path-ordering.js new file mode 100644 index 00000000000..e6b7bfab1e5 --- /dev/null +++ b/tests/rustdoc-js-std/path-ordering.js @@ -0,0 +1,20 @@ +const EXPECTED = [ + { + query: 'hashset::insert', + others: [ + // ensure hashset::insert comes first + { 'path': 'std::collections::hash_set::HashSet', 'name': 'insert' }, + { 'path': 'std::collections::hash_set::HashSet', 'name': 'get_or_insert' }, + { 'path': 'std::collections::hash_set::HashSet', 'name': 'get_or_insert_with' }, + { 'path': 'std::collections::hash_set::HashSet', 'name': 'get_or_insert_owned' }, + ], + }, + { + query: 'hash::insert', + others: [ + // ensure hashset/hashmap::insert come first + { 'path': 'std::collections::hash_map::HashMap', 'name': 'insert' }, + { 'path': 'std::collections::hash_set::HashSet', 'name': 'insert' }, + ], + }, +]; diff --git a/tests/rustdoc-js-std/primitive.js b/tests/rustdoc-js-std/primitive.js new file mode 100644 index 00000000000..737e429bf55 --- /dev/null +++ b/tests/rustdoc-js-std/primitive.js @@ -0,0 +1,72 @@ +const EXPECTED = [ + { + 'query': 'i8', + 'others': [ + { + 'path': 'std', + 'name': 'i8', + 'href': '../std/primitive.i8.html', + }, + ] + }, + { + 'query': 'u32', + 'others': [ + { + 'path': 'std', + 'name': 'u32', + 'href': '../std/primitive.u32.html', + }, + ] + }, + { + 'query': 'str', + 'others': [ + { + 'path': 'std', + 'name': 'str', + 'href': '../std/primitive.str.html', + }, + ] + }, + { + 'query': 'char', + 'others': [ + { + 'path': 'std', + 'name': 'char', + 'href': '../std/primitive.char.html', + }, + ] + }, + { + 'query': 'unit', + 'others': [ + { + 'path': 'std', + 'name': 'unit', + 'href': '../std/primitive.unit.html', + }, + ] + }, + { + 'query': 'tuple', + 'others': [ + { + 'path': 'std', + 'name': 'tuple', + 'href': '../std/primitive.tuple.html', + }, + ] + }, + { + 'query': 'fn', + 'others': [ + { + 'path': 'std', + 'name': 'fn', + 'href': '../std/primitive.fn.html', + }, + ] + }, +]; diff --git a/tests/rustdoc-js-std/println-typo.js b/tests/rustdoc-js-std/println-typo.js new file mode 100644 index 00000000000..a4dd90a44d5 --- /dev/null +++ b/tests/rustdoc-js-std/println-typo.js @@ -0,0 +1,12 @@ +// exact-check + +const FILTER_CRATE = 'std'; + +const EXPECTED = { + 'query': 'prinltn', + 'others': [ + { 'path': 'std', 'name': 'println' }, + { 'path': 'std', 'name': 'print' }, + { 'path': 'std', 'name': 'eprintln' }, + ], +}; diff --git a/tests/rustdoc-js-std/quoted.js b/tests/rustdoc-js-std/quoted.js new file mode 100644 index 00000000000..8a927501925 --- /dev/null +++ b/tests/rustdoc-js-std/quoted.js @@ -0,0 +1,21 @@ +// ignore-order + +const FILTER_CRATE = 'std'; + +const EXPECTED = { + 'query': '"error"', + 'others': [ + { 'path': 'std', 'name': 'error' }, + { 'path': 'std::fmt', 'name': 'Error' }, + { 'path': 'std::io', 'name': 'Error' }, + ], + 'in_args': [ + { 'path': 'std::fmt::Error', 'name': 'eq' }, + { 'path': 'std::fmt::Error', 'name': 'cmp' }, + { 'path': 'std::fmt::Error', 'name': 'partial_cmp' }, + + ], + 'returned': [ + { 'path': 'std::fmt::LowerExp', 'name': 'fmt' }, + ], +}; diff --git a/tests/rustdoc-js-std/reference-shrink.js b/tests/rustdoc-js-std/reference-shrink.js new file mode 100644 index 00000000000..b602bbdca18 --- /dev/null +++ b/tests/rustdoc-js-std/reference-shrink.js @@ -0,0 +1,7 @@ +// exact-check + +const EXPECTED = { + 'query': 'reference::shrink', + // avoid including the method that's not going to be in the HTML + 'others': [], +}; diff --git a/tests/rustdoc-js-std/regex.js b/tests/rustdoc-js-std/regex.js new file mode 100644 index 00000000000..7dc38939a17 --- /dev/null +++ b/tests/rustdoc-js-std/regex.js @@ -0,0 +1,9 @@ +// exact-check + +// https://github.com/rust-lang/rust/issues/103357 +const EXPECTED = { + 'query': 'regex', + 'others': [], + 'in_args': [], + 'returned': [], +}; diff --git a/tests/rustdoc-js-std/return-specific-literal.js b/tests/rustdoc-js-std/return-specific-literal.js new file mode 100644 index 00000000000..86ed3aceb4e --- /dev/null +++ b/tests/rustdoc-js-std/return-specific-literal.js @@ -0,0 +1,9 @@ +const EXPECTED = { + 'query': 'struct:"string"', + 'in_args': [ + { 'path': 'std::string::String', 'name': 'ne' }, + ], + 'returned': [ + { 'path': 'std::string::String', 'name': 'add' }, + ], +}; diff --git a/tests/rustdoc-js-std/return-specific.js b/tests/rustdoc-js-std/return-specific.js new file mode 100644 index 00000000000..be54a1c9772 --- /dev/null +++ b/tests/rustdoc-js-std/return-specific.js @@ -0,0 +1,9 @@ +const EXPECTED = { + 'query': 'struct:string', + 'in_args': [ + { 'path': 'std::string::String', 'name': 'ne' }, + ], + 'returned': [ + { 'path': 'std::string::String', 'name': 'add' }, + ], +}; diff --git a/tests/rustdoc-js-std/should-fail.js b/tests/rustdoc-js-std/should-fail.js new file mode 100644 index 00000000000..94f82efd9b4 --- /dev/null +++ b/tests/rustdoc-js-std/should-fail.js @@ -0,0 +1,8 @@ +// should-fail + +const EXPECTED = { + 'query': 'fn', + 'others': [ + { 'path': 'std', 'name': 'fn', ty: 14 }, + ], +}; diff --git a/tests/rustdoc-js-std/simd-type-signatures.js b/tests/rustdoc-js-std/simd-type-signatures.js new file mode 100644 index 00000000000..c07f15dcbe8 --- /dev/null +++ b/tests/rustdoc-js-std/simd-type-signatures.js @@ -0,0 +1,70 @@ +// exact-check +// ignore-order +// ignore-tidy-linelength + +// This test case verifies that the href points at the correct impl + +const FILTER_CRATE = "std"; + +const EXPECTED = [ + { + 'query': 'simd<i16>, simd<i16> -> simd<i16>', + 'others': [ + { + 'path': 'std::simd::prelude::Simd', + 'name': 'simd_max', + 'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_max' + }, + { + 'path': 'std::simd::prelude::Simd', + 'name': 'simd_min', + 'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_min' + }, + { + 'path': 'std::simd::prelude::Simd', + 'name': 'simd_clamp', + 'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_clamp' + }, + { + 'path': 'std::simd::prelude::Simd', + 'name': 'saturating_add', + 'href': '../std/simd/prelude/struct.Simd.html#impl-SimdInt-for-Simd%3Ci16,+N%3E/method.saturating_add' + }, + { + 'path': 'std::simd::prelude::Simd', + 'name': 'saturating_sub', + 'href': '../std/simd/prelude/struct.Simd.html#impl-SimdInt-for-Simd%3Ci16,+N%3E/method.saturating_sub' + }, + ], + }, + { + 'query': 'simd<i8>, simd<i8> -> simd<i8>', + 'others': [ + { + 'path': 'std::simd::prelude::Simd', + 'name': 'simd_max', + 'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_max' + }, + { + 'path': 'std::simd::prelude::Simd', + 'name': 'simd_min', + 'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_min' + }, + { + 'path': 'std::simd::prelude::Simd', + 'name': 'simd_clamp', + 'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_clamp' + }, + { + 'path': 'std::simd::prelude::Simd', + 'name': 'saturating_add', + 'href': '../std/simd/prelude/struct.Simd.html#impl-SimdInt-for-Simd%3Ci8,+N%3E/method.saturating_add' + }, + { + 'path': 'std::simd::prelude::Simd', + 'name': 'saturating_sub', + 'href': '../std/simd/prelude/struct.Simd.html#impl-SimdInt-for-Simd%3Ci8,+N%3E/method.saturating_sub' + }, + ], + }, +]; diff --git a/tests/rustdoc-js-std/string-from_ut.js b/tests/rustdoc-js-std/string-from_ut.js new file mode 100644 index 00000000000..1fff6ee28bb --- /dev/null +++ b/tests/rustdoc-js-std/string-from_ut.js @@ -0,0 +1,10 @@ +const EXPECTED = { + 'query': 'String::from_ut', + 'others': [ + { 'path': 'std::string::String', 'name': 'from_utf8' }, + { 'path': 'std::string::String', 'name': 'from_utf8' }, + { 'path': 'std::string::String', 'name': 'from_utf8_lossy' }, + { 'path': 'std::string::String', 'name': 'from_utf16_lossy' }, + { 'path': 'std::string::String', 'name': 'from_utf8_unchecked' }, + ], +}; diff --git a/tests/rustdoc-js-std/struct-vec.js b/tests/rustdoc-js-std/struct-vec.js new file mode 100644 index 00000000000..dd72aaa1ab8 --- /dev/null +++ b/tests/rustdoc-js-std/struct-vec.js @@ -0,0 +1,7 @@ +const EXPECTED = { + 'query': 'struct:VecD', + 'others': [ + { 'path': 'std::collections', 'name': 'VecDeque' }, + { 'path': 'std::vec', 'name': 'Vec' }, + ], +}; diff --git a/tests/rustdoc-js-std/typed-query.js b/tests/rustdoc-js-std/typed-query.js new file mode 100644 index 00000000000..8e84645889a --- /dev/null +++ b/tests/rustdoc-js-std/typed-query.js @@ -0,0 +1,13 @@ +// exact-check + +const FILTER_CRATE = 'std'; + +const EXPECTED = { + 'query': 'macro:print', + 'others': [ + { 'path': 'std', 'name': 'print' }, + { 'path': 'std', 'name': 'println' }, + { 'path': 'std', 'name': 'eprint' }, + { 'path': 'std', 'name': 'eprintln' }, + ], +}; diff --git a/tests/rustdoc-js-std/vec-new.js b/tests/rustdoc-js-std/vec-new.js new file mode 100644 index 00000000000..bb122ff4398 --- /dev/null +++ b/tests/rustdoc-js-std/vec-new.js @@ -0,0 +1,50 @@ +const EXPECTED = [ + { + 'query': 'Vec::new', + 'others': [ + { 'path': 'std::vec::Vec', 'name': 'new' }, + { 'path': 'std::vec::Vec', 'name': 'new_in' }, + ], + }, + { + 'query': 'prelude::vec', + 'others': [ + { 'path': 'std::prelude::rust_2024', 'name': 'Vec' }, + ], + }, + { + 'query': 'Vec new', + 'others': [ + { 'path': 'std::vec::Vec', 'name': 'new' }, + { 'path': 'std::vec::Vec', 'name': 'new_in' }, + ], + }, + { + 'query': 'std::Vec::new', + 'others': [ + { 'path': 'std::vec::Vec', 'name': 'new' }, + { 'path': 'std::vec::Vec', 'name': 'new_in' }, + ], + }, + { + 'query': 'std Vec new', + 'others': [ + { 'path': 'std::vec::Vec', 'name': 'new' }, + { 'path': 'std::vec::Vec', 'name': 'new_in' }, + ], + }, + { + 'query': 'alloc::Vec::new', + 'others': [ + { 'path': 'alloc::vec::Vec', 'name': 'new' }, + { 'path': 'alloc::vec::Vec', 'name': 'new_in' }, + ], + }, + { + 'query': 'alloc Vec new', + 'others': [ + { 'path': 'alloc::vec::Vec', 'name': 'new' }, + { 'path': 'alloc::vec::Vec', 'name': 'new_in' }, + ], + }, +]; diff --git a/tests/rustdoc-js-std/vec-type-signatures.js b/tests/rustdoc-js-std/vec-type-signatures.js new file mode 100644 index 00000000000..18cf9d6efd0 --- /dev/null +++ b/tests/rustdoc-js-std/vec-type-signatures.js @@ -0,0 +1,22 @@ +// ignore-order + +const FILTER_CRATE = "std"; + +const EXPECTED = [ + { + 'query': 'vec::intoiter<T> -> [T]', + 'others': [ + { 'path': 'std::vec::IntoIter', 'name': 'as_slice' }, + { 'path': 'std::vec::IntoIter', 'name': 'as_mut_slice' }, + { 'path': 'std::vec::IntoIter', 'name': 'next_chunk' }, + ], + }, + { + 'query': 'vec::intoiter<T> -> []', + 'others': [ + { 'path': 'std::vec::IntoIter', 'name': 'as_slice' }, + { 'path': 'std::vec::IntoIter', 'name': 'as_mut_slice' }, + { 'path': 'std::vec::IntoIter', 'name': 'next_chunk' }, + ], + }, +]; |