The Rust Book for " +
+ "introductions to language features and the language itself.
Docs.rs for documentation of crates released on" +
+ " crates.io.
";
}
+ return [output, array.length];
+}
- function makeTabHeader(tabNb, text, nbElems) {
- // https://blog.horizon-eda.org/misc/2020/02/19/ui.html
+function makeTabHeader(tabNb, text, nbElems) {
+ // https://blog.horizon-eda.org/misc/2020/02/19/ui.html
+ //
+ // CSS runs with `font-variant-numeric: tabular-nums` to ensure all
+ // digits are the same width. \u{2007} is a Unicode space character
+ // that is defined to be the same width as a digit.
+ const fmtNbElems =
+ nbElems < 10 ? `\u{2007}(${nbElems})\u{2007}\u{2007}` :
+ nbElems < 100 ? `\u{2007}(${nbElems})\u{2007}` : `\u{2007}(${nbElems})`;
+ if (searchState.currentTab === tabNb) {
+ return "";
+ }
+ return "";
+}
+
+/**
+ * @param {ResultsTable} results
+ * @param {boolean} go_to_first
+ * @param {string} filterCrates
+ */
+async function showResults(results, go_to_first, filterCrates) {
+ const search = searchState.outputElement();
+ if (go_to_first || (results.others.length === 1
+ && getSettingValue("go-to-only-result") === "true")
+ ) {
+ // Needed to force re-execution of JS when coming back to a page. Let's take this
+ // scenario as example:
//
- // CSS runs with `font-variant-numeric: tabular-nums` to ensure all
- // digits are the same width. \u{2007} is a Unicode space character
- // that is defined to be the same width as a digit.
- const fmtNbElems =
- nbElems < 10 ? `\u{2007}(${nbElems})\u{2007}\u{2007}` :
- nbElems < 100 ? `\u{2007}(${nbElems})\u{2007}` :
- `\u{2007}(${nbElems})`;
- if (searchState.currentTab === tabNb) {
- return "";
- }
- return "";
+ // 1. You have the "Directly go to item in search if there is only one result" option
+ // enabled.
+ // 2. You make a search which results only one result, leading you automatically to
+ // this result.
+ // 3. You go back to previous page.
+ //
+ // Now, without the call below, the JS will not be re-executed and the previous state
+ // will be used, starting search again since the search input is not empty, leading you
+ // back to the previous page again.
+ window.onunload = () => { };
+ searchState.removeQueryParameters();
+ const elem = document.createElement("a");
+ elem.href = results.others[0].href;
+ removeClass(elem, "active");
+ // For firefox, we need the element to be in the DOM so it can be clicked.
+ document.body.appendChild(elem);
+ elem.click();
+ return;
+ }
+ if (results.query === undefined) {
+ results.query = DocSearch.parseQuery(searchState.input.value);
}
- /**
- * @param {ResultsTable} results
- * @param {boolean} go_to_first
- * @param {string} filterCrates
- */
- async function showResults(results, go_to_first, filterCrates) {
- const search = searchState.outputElement();
- if (go_to_first || (results.others.length === 1
- && getSettingValue("go-to-only-result") === "true")
- ) {
- // Needed to force re-execution of JS when coming back to a page. Let's take this
- // scenario as example:
- //
- // 1. You have the "Directly go to item in search if there is only one result" option
- // enabled.
- // 2. You make a search which results only one result, leading you automatically to
- // this result.
- // 3. You go back to previous page.
- //
- // Now, without the call below, the JS will not be re-executed and the previous state
- // will be used, starting search again since the search input is not empty, leading you
- // back to the previous page again.
- window.onunload = () => {};
- searchState.removeQueryParameters();
- const elem = document.createElement("a");
- elem.href = results.others[0].href;
- removeClass(elem, "active");
- // For firefox, we need the element to be in the DOM so it can be clicked.
- document.body.appendChild(elem);
- elem.click();
- return;
- }
- if (results.query === undefined) {
- results.query = parseQuery(searchState.input.value);
- }
+ currentResults = results.query.userQuery;
- currentResults = results.query.userQuery;
+ const [ret_others, ret_in_args, ret_returned] = await Promise.all([
+ addTab(results.others, results.query, true),
+ addTab(results.in_args, results.query, false),
+ addTab(results.returned, results.query, false),
+ ]);
- const [ret_others, ret_in_args, ret_returned] = await Promise.all([
- addTab(results.others, results.query, true),
- addTab(results.in_args, results.query, false),
- addTab(results.returned, results.query, false),
- ]);
-
- // Navigate to the relevant tab if the current tab is empty, like in case users search
- // for "-> String". If they had selected another tab previously, they have to click on
- // it again.
- let currentTab = searchState.currentTab;
- if ((currentTab === 0 && ret_others[1] === 0) ||
- (currentTab === 1 && ret_in_args[1] === 0) ||
- (currentTab === 2 && ret_returned[1] === 0)) {
- if (ret_others[1] !== 0) {
- currentTab = 0;
- } else if (ret_in_args[1] !== 0) {
- currentTab = 1;
- } else if (ret_returned[1] !== 0) {
- currentTab = 2;
- }
- }
-
- let crates = "";
- if (rawSearchIndex.size > 1) {
- crates = " in ";
- }
-
- let output = `
" +
- makeTabHeader(0, "In Names", ret_others[1]) +
- "
";
+ // Navigate to the relevant tab if the current tab is empty, like in case users search
+ // for "-> String". If they had selected another tab previously, they have to click on
+ // it again.
+ let currentTab = searchState.currentTab;
+ if ((currentTab === 0 && ret_others[1] === 0) ||
+ (currentTab === 1 && ret_in_args[1] === 0) ||
+ (currentTab === 2 && ret_returned[1] === 0)) {
+ if (ret_others[1] !== 0) {
currentTab = 0;
- } else if (results.query.foundElems <= 1 && results.query.returned.length === 0) {
- output += "
" +
- makeTabHeader(0, "In Names", ret_others[1]) +
- makeTabHeader(1, "In Parameters", ret_in_args[1]) +
- makeTabHeader(2, "In Return Types", ret_returned[1]) +
- "
";
- } else {
- const signatureTabTitle =
- results.query.elems.length === 0 ? "In Function Return Types" :
+ } else if (ret_in_args[1] !== 0) {
+ currentTab = 1;
+ } else if (ret_returned[1] !== 0) {
+ currentTab = 2;
+ }
+ }
+
+ let crates = "";
+ if (rawSearchIndex.size > 1) {
+ crates = " in ";
+ }
+
+ let output = `
" +
+ `Type "${orig}" not found and used as generic parameter. ` +
+ `Consider searching for "${targ}" instead.
`;
}
- /**
- * Perform a search based on the current state of the search input element
- * and display the results.
- * @param {boolean} [forced]
- */
- async function search(forced) {
- const query = parseQuery(searchState.input.value.trim());
- let filterCrates = getFilterCrates();
+ const resultsElem = document.createElement("div");
+ resultsElem.id = "results";
+ resultsElem.appendChild(ret_others[0]);
+ resultsElem.appendChild(ret_in_args[0]);
+ resultsElem.appendChild(ret_returned[0]);
- if (!forced && query.userQuery === currentResults) {
- if (query.userQuery.length > 0) {
- putBackSearch();
- }
- return;
- }
-
- searchState.setLoadingSearch();
-
- const params = searchState.getQueryStringParams();
-
- // In case we have no information about the saved crate and there is a URL query parameter,
- // we override it with the URL query parameter.
- if (filterCrates === null && params["filter-crate"] !== undefined) {
- filterCrates = params["filter-crate"];
- }
-
- // Update document title to maintain a meaningful browser history
- searchState.title = "\"" + query.original + "\" Search - Rust";
-
- // Because searching is incremental by character, only the most
- // recent search query is added to the browser history.
- updateSearchHistory(buildUrl(query.original, filterCrates));
-
- await showResults(
- await execQuery(query, filterCrates, window.currentCrate),
- params.go_to_first,
- filterCrates);
+ search.innerHTML = output;
+ const crateSearch = document.getElementById("crate-search");
+ if (crateSearch) {
+ crateSearch.addEventListener("input", updateCrate);
}
-
- /**
- * Convert a list of RawFunctionType / ID to object-based FunctionType.
- *
- * Crates often have lots of functions in them, and it's common to have a large number of
- * functions that operate on a small set of data types, so the search index compresses them
- * by encoding function parameter and return types as indexes into an array of names.
- *
- * Even when a general-purpose compression algorithm is used, this is still a win. I checked.
- * https://github.com/rust-lang/rust/pull/98475#issue-1284395985
- *
- * The format for individual function types is encoded in
- * librustdoc/html/render/mod.rs: impl Serialize for RenderType
- *
- * @param {null|Array} types
- * @param {Array<{name: string, ty: number}>} lowercasePaths
- *
- * @return {Array}
- */
- function buildItemSearchTypeAll(types, lowercasePaths) {
- return types.length > 0 ?
- types.map(type => buildItemSearchType(type, lowercasePaths)) :
- EMPTY_GENERICS_ARRAY;
+ search.appendChild(resultsElem);
+ // Reset focused elements.
+ searchState.showResults(search);
+ const elems = document.getElementById("search-tabs").childNodes;
+ searchState.focusedByTab = [];
+ let i = 0;
+ for (const elem of elems) {
+ const j = i;
+ elem.onclick = () => printTab(j);
+ searchState.focusedByTab.push(null);
+ i += 1;
}
+ printTab(currentTab);
+}
- /**
- * Empty, immutable map used in item search types with no bindings.
- *
- * @type {Map>}
- */
- const EMPTY_BINDINGS_MAP = new Map();
-
- /**
- * Empty, immutable map used in item search types with no bindings.
- *
- * @type {Array}
- */
- const EMPTY_GENERICS_ARRAY = [];
-
- /**
- * Object pool for function types with no bindings or generics.
- * This is reset after loading the index.
- *
- * @type {Map}
- */
- let TYPES_POOL = new Map();
-
- /**
- * Converts a single type.
- *
- * @param {RawFunctionType} type
- */
- function buildItemSearchType(type, lowercasePaths, isAssocType) {
- const PATH_INDEX_DATA = 0;
- const GENERICS_DATA = 1;
- const BINDINGS_DATA = 2;
- let pathIndex, generics, bindings;
- if (typeof type === "number") {
- pathIndex = type;
- generics = EMPTY_GENERICS_ARRAY;
- bindings = EMPTY_BINDINGS_MAP;
- } else {
- pathIndex = type[PATH_INDEX_DATA];
- generics = buildItemSearchTypeAll(
- type[GENERICS_DATA],
- lowercasePaths,
- );
- if (type.length > BINDINGS_DATA && type[BINDINGS_DATA].length > 0) {
- bindings = new Map(type[BINDINGS_DATA].map(binding => {
- const [assocType, constraints] = binding;
- // Associated type constructors are represented sloppily in rustdoc's
- // type search, to make the engine simpler.
- //
- // MyType=Result> is equivalent to MyType>=T>
- // and both are, essentially
- // MyType)>, except the tuple isn't actually there.
- // It's more like the value of a type binding is naturally an array,
- // which rustdoc calls "constraints".
- //
- // As a result, the key should never have generics on it.
- return [
- buildItemSearchType(assocType, lowercasePaths, true).id,
- buildItemSearchTypeAll(constraints, lowercasePaths),
- ];
- }));
- } else {
- bindings = EMPTY_BINDINGS_MAP;
- }
- }
- /**
- * @type {FunctionType}
- */
- let result;
- if (pathIndex < 0) {
- // types less than 0 are generic parameters
- // the actual names of generic parameters aren't stored, since they aren't API
- result = {
- id: pathIndex,
- ty: TY_GENERIC,
- path: null,
- exactPath: null,
- generics,
- bindings,
- };
- } else if (pathIndex === 0) {
- // `0` is used as a sentinel because it's fewer bytes than `null`
- result = {
- id: null,
- ty: null,
- path: null,
- exactPath: null,
- generics,
- bindings,
- };
- } else {
- const item = lowercasePaths[pathIndex - 1];
- result = {
- id: buildTypeMapIndex(item.name, isAssocType),
- ty: item.ty,
- path: item.path,
- exactPath: item.exactPath,
- generics,
- bindings,
- };
- }
- const cr = TYPES_POOL.get(result.id);
- if (cr) {
- // Shallow equality check. Since this function is used
- // to construct every type object, this should be mostly
- // equivalent to a deep equality check, except if there's
- // a conflict, we don't keep the old one around, so it's
- // not a fully precise implementation of hashcons.
- if (cr.generics.length === result.generics.length &&
- cr.generics !== result.generics &&
- cr.generics.every((x, i) => result.generics[i] === x)
- ) {
- result.generics = cr.generics;
- }
- if (cr.bindings.size === result.bindings.size && cr.bindings !== result.bindings) {
- let ok = true;
- for (const [k, v] of cr.bindings.entries()) {
- const v2 = result.bindings.get(v);
- if (!v2) {
- ok = false;
- break;
- }
- if (v !== v2 && v.length === v2.length && v.every((x, i) => v2[i] === x)) {
- result.bindings.set(k, v);
- } else if (v !== v2) {
- ok = false;
- break;
- }
- }
- if (ok) {
- result.bindings = cr.bindings;
- }
- }
- if (cr.ty === result.ty && cr.path === result.path
- && cr.bindings === result.bindings && cr.generics === result.generics
- && cr.ty === result.ty
- ) {
- return cr;
- }
- }
- TYPES_POOL.set(result.id, result);
- return result;
+function updateSearchHistory(url) {
+ if (!browserSupportsHistoryApi()) {
+ return;
}
-
- /**
- * Convert from RawFunctionSearchType to FunctionSearchType.
- *
- * Crates often have lots of functions in them, and function signatures are sometimes complex,
- * so rustdoc uses a pretty tight encoding for them. This function converts it to a simpler,
- * object-based encoding so that the actual search code is more readable and easier to debug.
- *
- * The raw function search type format is generated using serde in
- * librustdoc/html/render/mod.rs: IndexItemFunctionType::write_to_string
- *
- * @param {Array<{name: string, ty: number}>} lowercasePaths
- *
- * @return {null|FunctionSearchType}
- */
- function buildFunctionSearchTypeCallback(lowercasePaths) {
- return functionSearchType => {
- if (functionSearchType === 0) {
- return null;
- }
- const INPUTS_DATA = 0;
- const OUTPUT_DATA = 1;
- let inputs, output;
- if (typeof functionSearchType[INPUTS_DATA] === "number") {
- inputs = [buildItemSearchType(functionSearchType[INPUTS_DATA], lowercasePaths)];
- } else {
- inputs = buildItemSearchTypeAll(
- functionSearchType[INPUTS_DATA],
- lowercasePaths,
- );
- }
- if (functionSearchType.length > 1) {
- if (typeof functionSearchType[OUTPUT_DATA] === "number") {
- output = [buildItemSearchType(functionSearchType[OUTPUT_DATA], lowercasePaths)];
- } else {
- output = buildItemSearchTypeAll(
- functionSearchType[OUTPUT_DATA],
- lowercasePaths,
- );
- }
- } else {
- output = [];
- }
- const where_clause = [];
- const l = functionSearchType.length;
- for (let i = 2; i < l; ++i) {
- where_clause.push(typeof functionSearchType[i] === "number"
- ? [buildItemSearchType(functionSearchType[i], lowercasePaths)]
- : buildItemSearchTypeAll(functionSearchType[i], lowercasePaths));
- }
- return {
- inputs, output, where_clause,
- };
- };
+ const params = searchState.getQueryStringParams();
+ if (!history.state && !params.search) {
+ history.pushState(null, "", url);
+ } else {
+ history.replaceState(null, "", url);
}
+}
- /**
- * Type fingerprints allow fast, approximate matching of types.
- *
- * This algo creates a compact representation of the type set using a Bloom filter.
- * This fingerprint is used three ways:
- *
- * - It accelerates the matching algorithm by checking the function fingerprint against the
- * query fingerprint. If any bits are set in the query but not in the function, it can't
- * match.
- *
- * - The fourth section has the number of distinct items in the set.
- * This is the distance function, used for filtering and for sorting.
- *
- * [^1]: Distance is the relatively naive metric of counting the number of distinct items in
- * the function that are not present in the query.
- *
- * @param {FunctionType|QueryElement} type - a single type
- * @param {Uint32Array} output - write the fingerprint to this data structure: uses 128 bits
- * @param {Set} fps - Set of distinct items
- */
- function buildFunctionTypeFingerprint(type, output, fps) {
- let input = type.id;
- // All forms of `[]`/`()`/`->` get collapsed down to one thing in the bloom filter.
- // Differentiating between arrays and slices, if the user asks for it, is
- // still done in the matching algorithm.
- if (input === typeNameIdOfArray || input === typeNameIdOfSlice) {
- input = typeNameIdOfArrayOrSlice;
- }
- if (input === typeNameIdOfTuple || input === typeNameIdOfUnit) {
- input = typeNameIdOfTupleOrUnit;
- }
- if (input === typeNameIdOfFn || input === typeNameIdOfFnMut ||
- input === typeNameIdOfFnOnce) {
- input = typeNameIdOfHof;
- }
- // http://burtleburtle.net/bob/hash/integer.html
- // ~~ is toInt32. It's used before adding, so
- // the number stays in safe integer range.
- const hashint1 = k => {
- k = (~~k + 0x7ed55d16) + (k << 12);
- k = (k ^ 0xc761c23c) ^ (k >>> 19);
- k = (~~k + 0x165667b1) + (k << 5);
- k = (~~k + 0xd3a2646c) ^ (k << 9);
- k = (~~k + 0xfd7046c5) + (k << 3);
- return (k ^ 0xb55a4f09) ^ (k >>> 16);
- };
- const hashint2 = k => {
- k = ~k + (k << 15);
- k ^= k >>> 12;
- k += k << 2;
- k ^= k >>> 4;
- k = Math.imul(k, 2057);
- return k ^ (k >> 16);
- };
- if (input !== null) {
- const h0a = hashint1(input);
- const h0b = hashint2(input);
- // Less Hashing, Same Performance: Building a Better Bloom Filter
- // doi=10.1.1.72.2442
- const h1a = ~~(h0a + Math.imul(h0b, 2));
- const h1b = ~~(h0a + Math.imul(h0b, 3));
- const h2a = ~~(h0a + Math.imul(h0b, 4));
- const h2b = ~~(h0a + Math.imul(h0b, 5));
- output[0] |= (1 << (h0a % 32)) | (1 << (h1b % 32));
- output[1] |= (1 << (h1a % 32)) | (1 << (h2b % 32));
- output[2] |= (1 << (h2a % 32)) | (1 << (h0b % 32));
- fps.add(input);
- }
- for (const g of type.generics) {
- buildFunctionTypeFingerprint(g, output, fps);
- }
- const fb = {
- id: null,
- ty: 0,
- generics: EMPTY_GENERICS_ARRAY,
- bindings: EMPTY_BINDINGS_MAP,
- };
- for (const [k, v] of type.bindings.entries()) {
- fb.id = k;
- fb.generics = v;
- buildFunctionTypeFingerprint(fb, output, fps);
- }
- output[3] = fps.size;
- }
+/**
+ * Perform a search based on the current state of the search input element
+ * and display the results.
+ * @param {boolean} [forced]
+ */
+async function search(forced) {
+ const query = DocSearch.parseQuery(searchState.input.value.trim());
+ let filterCrates = getFilterCrates();
- /**
- * Compare the query fingerprint with the function fingerprint.
- *
- * @param {{number}} fullId - The function
- * @param {{Uint32Array}} queryFingerprint - The query
- * @returns {number|null} - Null if non-match, number if distance
- * This function might return 0!
- */
- function compareTypeFingerprints(fullId, queryFingerprint) {
- const fh0 = functionTypeFingerprint[fullId * 4];
- const fh1 = functionTypeFingerprint[(fullId * 4) + 1];
- const fh2 = functionTypeFingerprint[(fullId * 4) + 2];
- const [qh0, qh1, qh2] = queryFingerprint;
- // Approximate set intersection with bloom filters.
- // This can be larger than reality, not smaller, because hashes have
- // the property that if they've got the same value, they hash to the
- // same thing. False positives exist, but not false negatives.
- const [in0, in1, in2] = [fh0 & qh0, fh1 & qh1, fh2 & qh2];
- // Approximate the set of items in the query but not the function.
- // This might be smaller than reality, but cannot be bigger.
- //
- // | in_ | qh_ | XOR | Meaning |
- // | --- | --- | --- | ------------------------------------------------ |
- // | 0 | 0 | 0 | Not present |
- // | 1 | 0 | 1 | IMPOSSIBLE because `in_` is `fh_ & qh_` |
- // | 1 | 1 | 0 | If one or both is false positive, false negative |
- // | 0 | 1 | 1 | Since in_ has no false negatives, must be real |
- if ((in0 ^ qh0) || (in1 ^ qh1) || (in2 ^ qh2)) {
- return null;
- }
- return functionTypeFingerprint[(fullId * 4) + 3];
- }
-
- class VlqHexDecoder {
- constructor(string, cons) {
- this.string = string;
- this.cons = cons;
- this.offset = 0;
- this.backrefQueue = [];
- }
- // call after consuming `{`
- decodeList() {
- let c = this.string.charCodeAt(this.offset);
- const ret = [];
- while (c !== 125) { // 125 = "}"
- ret.push(this.decode());
- c = this.string.charCodeAt(this.offset);
- }
- this.offset += 1; // eat cb
- return ret;
- }
- // consumes and returns a list or integer
- decode() {
- let n = 0;
- let c = this.string.charCodeAt(this.offset);
- if (c === 123) { // 123 = "{"
- this.offset += 1;
- return this.decodeList();
- }
- while (c < 96) { // 96 = "`"
- n = (n << 4) | (c & 0xF);
- this.offset += 1;
- c = this.string.charCodeAt(this.offset);
- }
- // last character >= la
- n = (n << 4) | (c & 0xF);
- const [sign, value] = [n & 1, n >> 1];
- this.offset += 1;
- return sign ? -value : value;
- }
- next() {
- const c = this.string.charCodeAt(this.offset);
- // sixteen characters after "0" are backref
- if (c >= 48 && c < 64) { // 48 = "0", 64 = "@"
- this.offset += 1;
- return this.backrefQueue[c - 48];
- }
- // special exception: 0 doesn't use backref encoding
- // it's already one character, and it's always nullish
- if (c === 96) { // 96 = "`"
- this.offset += 1;
- return this.cons(0);
- }
- const result = this.cons(this.decode());
- this.backrefQueue.unshift(result);
- if (this.backrefQueue.length > 16) {
- this.backrefQueue.pop();
- }
- return result;
- }
- }
- class RoaringBitmap {
- constructor(str) {
- const strdecoded = atob(str);
- const u8array = new Uint8Array(strdecoded.length);
- for (let j = 0; j < strdecoded.length; ++j) {
- u8array[j] = strdecoded.charCodeAt(j);
- }
- const has_runs = u8array[0] === 0x3b;
- const size = has_runs ?
- ((u8array[2] | (u8array[3] << 8)) + 1) :
- ((u8array[4] | (u8array[5] << 8) | (u8array[6] << 16) | (u8array[7] << 24)));
- let i = has_runs ? 4 : 8;
- let is_run;
- if (has_runs) {
- const is_run_len = Math.floor((size + 7) / 8);
- is_run = u8array.slice(i, i + is_run_len);
- i += is_run_len;
- } else {
- is_run = new Uint8Array();
- }
- this.keys = [];
- this.cardinalities = [];
- for (let j = 0; j < size; ++j) {
- this.keys.push(u8array[i] | (u8array[i + 1] << 8));
- i += 2;
- this.cardinalities.push((u8array[i] | (u8array[i + 1] << 8)) + 1);
- i += 2;
- }
- this.containers = [];
- let offsets = null;
- if (!has_runs || this.keys.length >= 4) {
- offsets = [];
- for (let j = 0; j < size; ++j) {
- offsets.push(u8array[i] | (u8array[i + 1] << 8) | (u8array[i + 2] << 16) |
- (u8array[i + 3] << 24));
- i += 4;
- }
- }
- for (let j = 0; j < size; ++j) {
- if (offsets && offsets[j] !== i) {
- console.log(this.containers);
- throw new Error(`corrupt bitmap ${j}: ${i} / ${offsets[j]}`);
- }
- if (is_run[j >> 3] & (1 << (j & 0x7))) {
- const runcount = (u8array[i] | (u8array[i + 1] << 8));
- i += 2;
- this.containers.push(new RoaringBitmapRun(
- runcount,
- u8array.slice(i, i + (runcount * 4)),
- ));
- i += runcount * 4;
- } else if (this.cardinalities[j] >= 4096) {
- this.containers.push(new RoaringBitmapBits(u8array.slice(i, i + 8192)));
- i += 8192;
- } else {
- const end = this.cardinalities[j] * 2;
- this.containers.push(new RoaringBitmapArray(
- this.cardinalities[j],
- u8array.slice(i, i + end),
- ));
- i += end;
- }
- }
- }
- contains(keyvalue) {
- const key = keyvalue >> 16;
- const value = keyvalue & 0xFFFF;
- for (let i = 0; i < this.keys.length; ++i) {
- if (this.keys[i] === key) {
- return this.containers[i].contains(value);
- }
- }
- return false;
- }
- }
-
- class RoaringBitmapRun {
- constructor(runcount, array) {
- this.runcount = runcount;
- this.array = array;
- }
- contains(value) {
- const l = this.runcount * 4;
- for (let i = 0; i < l; i += 4) {
- const start = this.array[i] | (this.array[i + 1] << 8);
- const lenm1 = this.array[i + 2] | (this.array[i + 3] << 8);
- if (value >= start && value <= (start + lenm1)) {
- return true;
- }
- }
- return false;
- }
- }
- class RoaringBitmapArray {
- constructor(cardinality, array) {
- this.cardinality = cardinality;
- this.array = array;
- }
- contains(value) {
- const l = this.cardinality * 2;
- for (let i = 0; i < l; i += 2) {
- const start = this.array[i] | (this.array[i + 1] << 8);
- if (value === start) {
- return true;
- }
- }
- return false;
- }
- }
- class RoaringBitmapBits {
- constructor(array) {
- this.array = array;
- }
- contains(value) {
- return !!(this.array[value >> 3] & (1 << (value & 7)));
- }
- }
-
- /**
- * Convert raw search index into in-memory search index.
- *
- * @param {[string, RawSearchIndexCrate][]} rawSearchIndex
- */
- function buildIndex(rawSearchIndex) {
- searchIndex = [];
- searchIndexDeprecated = new Map();
- searchIndexEmptyDesc = new Map();
- let currentIndex = 0;
- let id = 0;
-
- // Function type fingerprints are 128-bit bloom filters that are used to
- // estimate the distance between function and query.
- // This loop counts the number of items to allocate a fingerprint for.
- for (const crate of rawSearchIndex.values()) {
- // Each item gets an entry in the fingerprint array, and the crate
- // does, too
- id += crate.t.length + 1;
- }
- functionTypeFingerprint = new Uint32Array((id + 1) * 4);
-
- // This loop actually generates the search item indexes, including
- // normalized names, type signature objects and fingerprints, and aliases.
- id = 0;
-
- for (const [crate, crateCorpus] of rawSearchIndex) {
- // a string representing the lengths of each description shard
- // a string representing the list of function types
- const itemDescShardDecoder = new VlqHexDecoder(crateCorpus.D, noop => noop);
- let descShard = {
- crate,
- shard: 0,
- start: 0,
- len: itemDescShardDecoder.next(),
- promise: null,
- resolve: null,
- };
- const descShardList = [ descShard ];
-
- // Deprecated items and items with no description
- searchIndexDeprecated.set(crate, new RoaringBitmap(crateCorpus.c));
- searchIndexEmptyDesc.set(crate, new RoaringBitmap(crateCorpus.e));
- let descIndex = 0;
-
- // This object should have exactly the same set of fields as the "row"
- // object defined below. Your JavaScript runtime will thank you.
- // https://mathiasbynens.be/notes/shapes-ics
- const crateRow = {
- crate,
- ty: 3, // == ExternCrate
- name: crate,
- path: "",
- descShard,
- descIndex,
- exactPath: "",
- desc: crateCorpus.doc,
- parent: undefined,
- type: null,
- id,
- word: crate,
- normalizedName: crate.indexOf("_") === -1 ? crate : crate.replace(/_/g, ""),
- bitIndex: 0,
- implDisambiguator: null,
- };
- id += 1;
- searchIndex.push(crateRow);
- currentIndex += 1;
- if (!searchIndexEmptyDesc.get(crate).contains(0)) {
- descIndex += 1;
- }
-
- // a String of one character item type codes
- const itemTypes = crateCorpus.t;
- // an array of (String) item names
- const itemNames = crateCorpus.n;
- // an array of [(Number) item index,
- // (String) full path]
- // an item whose index is not present will fall back to the previous present path
- // i.e. if indices 4 and 11 are present, but 5-10 and 12-13 are not present,
- // 5-10 will fall back to the path for 4 and 12-13 will fall back to the path for 11
- const itemPaths = new Map(crateCorpus.q);
- // An array of [(Number) item index, (Number) path index]
- // Used to de-duplicate inlined and re-exported stuff
- const itemReexports = new Map(crateCorpus.r);
- // an array of (Number) the parent path index + 1 to `paths`, or 0 if none
- const itemParentIdxDecoder = new VlqHexDecoder(crateCorpus.i, noop => noop);
- // a map Number, string for impl disambiguators
- const implDisambiguator = new Map(crateCorpus.b);
- // an array of [(Number) item type,
- // (String) name]
- const paths = crateCorpus.p;
- // an array of [(String) alias name
- // [Number] index to items]
- const aliases = crateCorpus.a;
-
- // an array of [{name: String, ty: Number}]
- const lowercasePaths = [];
-
- // a string representing the list of function types
- const itemFunctionDecoder = new VlqHexDecoder(
- crateCorpus.f,
- buildFunctionSearchTypeCallback(lowercasePaths),
- );
-
- // convert `rawPaths` entries into object form
- // generate normalizedPaths for function search mode
- let len = paths.length;
- let lastPath = itemPaths.get(0);
- for (let i = 0; i < len; ++i) {
- const elem = paths[i];
- const ty = elem[0];
- const name = elem[1];
- let path = null;
- if (elem.length > 2) {
- path = itemPaths.has(elem[2]) ? itemPaths.get(elem[2]) : lastPath;
- lastPath = path;
- }
- const exactPath = elem.length > 3 ? itemPaths.get(elem[3]) : path;
-
- lowercasePaths.push({ty, name: name.toLowerCase(), path, exactPath});
- paths[i] = {ty, name, path, exactPath};
- }
-
- // convert `item*` into an object form, and construct word indices.
- //
- // before any analysis is performed lets gather the search terms to
- // search against apart from the rest of the data. This is a quick
- // operation that is cached for the life of the page state so that
- // all other search operations have access to this cached data for
- // faster analysis operations
- lastPath = "";
- len = itemTypes.length;
- let lastName = "";
- let lastWord = "";
- for (let i = 0; i < len; ++i) {
- const bitIndex = i + 1;
- if (descIndex >= descShard.len &&
- !searchIndexEmptyDesc.get(crate).contains(bitIndex)) {
- descShard = {
- crate,
- shard: descShard.shard + 1,
- start: descShard.start + descShard.len,
- len: itemDescShardDecoder.next(),
- promise: null,
- resolve: null,
- };
- descIndex = 0;
- descShardList.push(descShard);
- }
- const name = itemNames[i] === "" ? lastName : itemNames[i];
- const word = itemNames[i] === "" ? lastWord : itemNames[i].toLowerCase();
- const path = itemPaths.has(i) ? itemPaths.get(i) : lastPath;
- const type = itemFunctionDecoder.next();
- if (type !== null) {
- if (type) {
- const fp = functionTypeFingerprint.subarray(id * 4, (id + 1) * 4);
- const fps = new Set();
- for (const t of type.inputs) {
- buildFunctionTypeFingerprint(t, fp, fps);
- }
- for (const t of type.output) {
- buildFunctionTypeFingerprint(t, fp, fps);
- }
- for (const w of type.where_clause) {
- for (const t of w) {
- buildFunctionTypeFingerprint(t, fp, fps);
- }
- }
- }
- }
- // This object should have exactly the same set of fields as the "crateRow"
- // object defined above.
- const itemParentIdx = itemParentIdxDecoder.next();
- const row = {
- crate,
- ty: itemTypes.charCodeAt(i) - 65, // 65 = "A"
- name,
- path,
- descShard,
- descIndex,
- exactPath: itemReexports.has(i) ? itemPaths.get(itemReexports.get(i)) : path,
- parent: itemParentIdx > 0 ? paths[itemParentIdx - 1] : undefined,
- type,
- id,
- word,
- normalizedName: word.indexOf("_") === -1 ? word : word.replace(/_/g, ""),
- bitIndex,
- implDisambiguator: implDisambiguator.has(i) ? implDisambiguator.get(i) : null,
- };
- id += 1;
- searchIndex.push(row);
- lastPath = row.path;
- if (!searchIndexEmptyDesc.get(crate).contains(bitIndex)) {
- descIndex += 1;
- }
- lastName = name;
- lastWord = word;
- }
-
- if (aliases) {
- const currentCrateAliases = new Map();
- ALIASES.set(crate, currentCrateAliases);
- for (const alias_name in aliases) {
- if (!Object.prototype.hasOwnProperty.call(aliases, alias_name)) {
- continue;
- }
-
- let currentNameAliases;
- if (currentCrateAliases.has(alias_name)) {
- currentNameAliases = currentCrateAliases.get(alias_name);
- } else {
- currentNameAliases = [];
- currentCrateAliases.set(alias_name, currentNameAliases);
- }
- for (const local_alias of aliases[alias_name]) {
- currentNameAliases.push(local_alias + currentIndex);
- }
- }
- }
- currentIndex += itemTypes.length;
- searchState.descShards.set(crate, descShardList);
- }
- // Drop the (rather large) hash table used for reusing function items
- TYPES_POOL = new Map();
- }
-
- /**
- * Callback for when the search form is submitted.
- * @param {Event} [e] - The event that triggered this call, if any
- */
- function onSearchSubmit(e) {
- e.preventDefault();
- searchState.clearInputTimeout();
- search();
- }
-
- function putBackSearch() {
- const search_input = searchState.input;
- if (!searchState.input) {
- return;
- }
- if (search_input.value !== "" && !searchState.isDisplayed()) {
- searchState.showResults();
- if (browserSupportsHistoryApi()) {
- history.replaceState(null, "",
- buildUrl(search_input.value, getFilterCrates()));
- }
- document.title = searchState.title;
- }
- }
-
- function registerSearchEvents() {
- const params = searchState.getQueryStringParams();
-
- // Populate search bar with query string search term when provided,
- // but only if the input bar is empty. This avoid the obnoxious issue
- // where you start trying to do a search, and the index loads, and
- // suddenly your search is gone!
- if (searchState.input.value === "") {
- searchState.input.value = params.search || "";
- }
-
- const searchAfter500ms = () => {
- searchState.clearInputTimeout();
- if (searchState.input.value.length === 0) {
- searchState.hideResults();
- } else {
- searchState.timeout = setTimeout(search, 500);
- }
- };
- searchState.input.onkeyup = searchAfter500ms;
- searchState.input.oninput = searchAfter500ms;
- document.getElementsByClassName("search-form")[0].onsubmit = onSearchSubmit;
- searchState.input.onchange = e => {
- if (e.target !== document.activeElement) {
- // To prevent doing anything when it's from a blur event.
- return;
- }
- // Do NOT e.preventDefault() here. It will prevent pasting.
- searchState.clearInputTimeout();
- // zero-timeout necessary here because at the time of event handler execution the
- // pasted content is not in the input field yet. Shouldn’t make any difference for
- // change, though.
- setTimeout(search, 0);
- };
- searchState.input.onpaste = searchState.input.onchange;
-
- searchState.outputElement().addEventListener("keydown", e => {
- // We only handle unmodified keystrokes here. We don't want to interfere with,
- // for instance, alt-left and alt-right for history navigation.
- if (e.altKey || e.ctrlKey || e.shiftKey || e.metaKey) {
- return;
- }
- // up and down arrow select next/previous search result, or the
- // search box if we're already at the top.
- if (e.which === 38) { // up
- const previous = document.activeElement.previousElementSibling;
- if (previous) {
- previous.focus();
- } else {
- searchState.focus();
- }
- e.preventDefault();
- } else if (e.which === 40) { // down
- const next = document.activeElement.nextElementSibling;
- if (next) {
- next.focus();
- }
- const rect = document.activeElement.getBoundingClientRect();
- if (window.innerHeight - rect.bottom < rect.height) {
- window.scrollBy(0, rect.height);
- }
- e.preventDefault();
- } else if (e.which === 37) { // left
- nextTab(-1);
- e.preventDefault();
- } else if (e.which === 39) { // right
- nextTab(1);
- e.preventDefault();
- }
- });
-
- searchState.input.addEventListener("keydown", e => {
- if (e.which === 40) { // down
- focusSearchResult();
- e.preventDefault();
- }
- });
-
- searchState.input.addEventListener("focus", () => {
+ if (!forced && query.userQuery === currentResults) {
+ if (query.userQuery.length > 0) {
putBackSearch();
- });
+ }
+ return;
+ }
- searchState.input.addEventListener("blur", () => {
- searchState.input.placeholder = searchState.input.origPlaceholder;
- });
+ searchState.setLoadingSearch();
- // Push and pop states are used to add search results to the browser
- // history.
+ const params = searchState.getQueryStringParams();
+
+ // In case we have no information about the saved crate and there is a URL query parameter,
+ // we override it with the URL query parameter.
+ if (filterCrates === null && params["filter-crate"] !== undefined) {
+ filterCrates = params["filter-crate"];
+ }
+
+ // Update document title to maintain a meaningful browser history
+ searchState.title = "\"" + query.original + "\" Search - Rust";
+
+ // Because searching is incremental by character, only the most
+ // recent search query is added to the browser history.
+ updateSearchHistory(buildUrl(query.original, filterCrates));
+
+ await showResults(
+ await docSearch.execQuery(query, filterCrates, window.currentCrate),
+ params.go_to_first,
+ filterCrates);
+}
+
+/**
+ * Callback for when the search form is submitted.
+ * @param {Event} [e] - The event that triggered this call, if any
+ */
+function onSearchSubmit(e) {
+ e.preventDefault();
+ searchState.clearInputTimeout();
+ search();
+}
+
+function putBackSearch() {
+ const search_input = searchState.input;
+ if (!searchState.input) {
+ return;
+ }
+ if (search_input.value !== "" && !searchState.isDisplayed()) {
+ searchState.showResults();
if (browserSupportsHistoryApi()) {
- // Store the previous so we can revert back to it later.
- const previousTitle = document.title;
-
- window.addEventListener("popstate", e => {
- const params = searchState.getQueryStringParams();
- // Revert to the previous title manually since the History
- // API ignores the title parameter.
- document.title = previousTitle;
- // When browsing forward to search results the previous
- // search will be repeated, so the currentResults are
- // cleared to ensure the search is successful.
- currentResults = null;
- // Synchronize search bar with query string state and
- // perform the search. This will empty the bar if there's
- // nothing there, which lets you really go back to a
- // previous state with nothing in the bar.
- if (params.search && params.search.length > 0) {
- searchState.input.value = params.search;
- // Some browsers fire "onpopstate" for every page load
- // (Chrome), while others fire the event only when actually
- // popping a state (Firefox), which is why search() is
- // called both here and at the end of the startSearch()
- // function.
- e.preventDefault();
- search();
- } else {
- searchState.input.value = "";
- // When browsing back from search results the main page
- // visibility must be reset.
- searchState.hideResults();
- }
- });
+ history.replaceState(null, "",
+ buildUrl(search_input.value, getFilterCrates()));
}
+ document.title = searchState.title;
+ }
+}
- // This is required in firefox to avoid this problem: Navigating to a search result
- // with the keyboard, hitting enter, and then hitting back would take you back to
- // the doc page, rather than the search that should overlay it.
- // This was an interaction between the back-forward cache and our handlers
- // that try to sync state between the URL and the search input. To work around it,
- // do a small amount of re-init on page show.
- window.onpageshow = () => {
- const qSearch = searchState.getQueryStringParams().search;
- if (searchState.input.value === "" && qSearch) {
- searchState.input.value = qSearch;
+function registerSearchEvents() {
+ const params = searchState.getQueryStringParams();
+
+ // Populate search bar with query string search term when provided,
+ // but only if the input bar is empty. This avoid the obnoxious issue
+ // where you start trying to do a search, and the index loads, and
+ // suddenly your search is gone!
+ if (searchState.input.value === "") {
+ searchState.input.value = params.search || "";
+ }
+
+ const searchAfter500ms = () => {
+ searchState.clearInputTimeout();
+ if (searchState.input.value.length === 0) {
+ searchState.hideResults();
+ } else {
+ searchState.timeout = setTimeout(search, 500);
+ }
+ };
+ searchState.input.onkeyup = searchAfter500ms;
+ searchState.input.oninput = searchAfter500ms;
+ document.getElementsByClassName("search-form")[0].onsubmit = onSearchSubmit;
+ searchState.input.onchange = e => {
+ if (e.target !== document.activeElement) {
+ // To prevent doing anything when it's from a blur event.
+ return;
+ }
+ // Do NOT e.preventDefault() here. It will prevent pasting.
+ searchState.clearInputTimeout();
+ // zero-timeout necessary here because at the time of event handler execution the
+ // pasted content is not in the input field yet. Shouldn’t make any difference for
+ // change, though.
+ setTimeout(search, 0);
+ };
+ searchState.input.onpaste = searchState.input.onchange;
+
+ searchState.outputElement().addEventListener("keydown", e => {
+ // We only handle unmodified keystrokes here. We don't want to interfere with,
+ // for instance, alt-left and alt-right for history navigation.
+ if (e.altKey || e.ctrlKey || e.shiftKey || e.metaKey) {
+ return;
+ }
+ // up and down arrow select next/previous search result, or the
+ // search box if we're already at the top.
+ if (e.which === 38) { // up
+ const previous = document.activeElement.previousElementSibling;
+ if (previous) {
+ previous.focus();
+ } else {
+ searchState.focus();
}
- search();
- };
- }
-
- function updateCrate(ev) {
- if (ev.target.value === "all crates") {
- // If we don't remove it from the URL, it'll be picked up again by the search.
- const query = searchState.input.value.trim();
- updateSearchHistory(buildUrl(query, null));
+ e.preventDefault();
+ } else if (e.which === 40) { // down
+ const next = document.activeElement.nextElementSibling;
+ if (next) {
+ next.focus();
+ }
+ const rect = document.activeElement.getBoundingClientRect();
+ if (window.innerHeight - rect.bottom < rect.height) {
+ window.scrollBy(0, rect.height);
+ }
+ e.preventDefault();
+ } else if (e.which === 37) { // left
+ nextTab(-1);
+ e.preventDefault();
+ } else if (e.which === 39) { // right
+ nextTab(1);
+ e.preventDefault();
}
- // In case you "cut" the entry from the search input, then change the crate filter
- // before paste back the previous search, you get the old search results without
- // the filter. To prevent this, we need to remove the previous results.
- currentResults = null;
- search(true);
+ });
+
+ searchState.input.addEventListener("keydown", e => {
+ if (e.which === 40) { // down
+ focusSearchResult();
+ e.preventDefault();
+ }
+ });
+
+ searchState.input.addEventListener("focus", () => {
+ putBackSearch();
+ });
+
+ searchState.input.addEventListener("blur", () => {
+ searchState.input.placeholder = searchState.input.origPlaceholder;
+ });
+
+ // Push and pop states are used to add search results to the browser
+ // history.
+ if (browserSupportsHistoryApi()) {
+ // Store the previous <title> so we can revert back to it later.
+ const previousTitle = document.title;
+
+ window.addEventListener("popstate", e => {
+ const params = searchState.getQueryStringParams();
+ // Revert to the previous title manually since the History
+ // API ignores the title parameter.
+ document.title = previousTitle;
+ // When browsing forward to search results the previous
+ // search will be repeated, so the currentResults are
+ // cleared to ensure the search is successful.
+ currentResults = null;
+ // Synchronize search bar with query string state and
+ // perform the search. This will empty the bar if there's
+ // nothing there, which lets you really go back to a
+ // previous state with nothing in the bar.
+ if (params.search && params.search.length > 0) {
+ searchState.input.value = params.search;
+ // Some browsers fire "onpopstate" for every page load
+ // (Chrome), while others fire the event only when actually
+ // popping a state (Firefox), which is why search() is
+ // called both here and at the end of the startSearch()
+ // function.
+ e.preventDefault();
+ search();
+ } else {
+ searchState.input.value = "";
+ // When browsing back from search results the main page
+ // visibility must be reset.
+ searchState.hideResults();
+ }
+ });
}
- buildIndex(rawSearchIndex);
+ // This is required in firefox to avoid this problem: Navigating to a search result
+ // with the keyboard, hitting enter, and then hitting back would take you back to
+ // the doc page, rather than the search that should overlay it.
+ // This was an interaction between the back-forward cache and our handlers
+ // that try to sync state between the URL and the search input. To work around it,
+ // do a small amount of re-init on page show.
+ window.onpageshow = () => {
+ const qSearch = searchState.getQueryStringParams().search;
+ if (searchState.input.value === "" && qSearch) {
+ searchState.input.value = qSearch;
+ }
+ search();
+ };
+}
+
+function updateCrate(ev) {
+ if (ev.target.value === "all crates") {
+ // If we don't remove it from the URL, it'll be picked up again by the search.
+ const query = searchState.input.value.trim();
+ updateSearchHistory(buildUrl(query, null));
+ }
+ // In case you "cut" the entry from the search input, then change the crate filter
+ // before paste back the previous search, you get the old search results without
+ // the filter. To prevent this, we need to remove the previous results.
+ currentResults = null;
+ search(true);
+}
+
+function initSearch(searchIndx) {
+ rawSearchIndex = searchIndx;
if (typeof window !== "undefined") {
+ docSearch = new DocSearch(rawSearchIndex, ROOT_PATH, searchState);
registerSearchEvents();
// If there's a search term in the URL, execute the search now.
if (window.searchState.getQueryStringParams().search) {
search();
}
+ } else if (typeof exports !== "undefined") {
+ docSearch = new DocSearch(rawSearchIndex, ROOT_PATH, searchState);
+ exports.docSearch = docSearch;
+ exports.parseQuery = DocSearch.parseQuery;
}
+}
- if (typeof exports !== "undefined") {
- exports.initSearch = initSearch;
- exports.execQuery = execQuery;
- exports.parseQuery = parseQuery;
- }
+if (typeof exports !== "undefined") {
+ exports.initSearch = initSearch;
}
if (typeof window !== "undefined") {
@@ -3897,6 +3938,4 @@ if (typeof window !== "undefined") {
// exports.
initSearch(new Map());
}
-
-
})();
diff --git a/src/tools/rustdoc-js/tester.js b/src/tools/rustdoc-js/tester.js
index 43a22f358c31..e162ba033cc5 100644
--- a/src/tools/rustdoc-js/tester.js
+++ b/src/tools/rustdoc-js/tester.js
@@ -427,7 +427,6 @@ function loadSearchJS(doc_folder, resource_suffix) {
return list[descIndex];
},
loadedDescShard: function(crate, shard, data) {
- //console.log(this.descShards);
this.descShards.get(crate)[shard].resolve(data.split("\n"));
},
};
@@ -436,15 +435,15 @@ function loadSearchJS(doc_folder, resource_suffix) {
const searchJs = fs.readdirSync(staticFiles).find(f => f.match(/search.*\.js$/));
const searchModule = require(path.join(staticFiles, searchJs));
searchModule.initSearch(searchIndex.searchIndex);
-
+ const docSearch = searchModule.docSearch;
return {
doSearch: function(queryStr, filterCrate, currentCrate) {
- return searchModule.execQuery(searchModule.parseQuery(queryStr),
+ return docSearch.execQuery(searchModule.parseQuery(queryStr),
filterCrate, currentCrate);
},
getCorrections: function(queryStr, filterCrate, currentCrate) {
const parsedQuery = searchModule.parseQuery(queryStr);
- searchModule.execQuery(parsedQuery, filterCrate, currentCrate);
+ docSearch.execQuery(parsedQuery, filterCrate, currentCrate);
return parsedQuery.correction;
},
parseQuery: searchModule.parseQuery,