src/librustdoc/html/static/main.js

   1 // From rust:
   2 /* global ALIASES, currentCrate, rootPath */
   3
   4 // Local js definitions:
   5 /* global addClass, getCurrentValue, hasClass */
   6 /* global isHidden onEach, removeClass, updateLocalStorage */
   7
   8 if (!String.prototype.startsWith) {
   9     String.prototype.startsWith = function(searchString, position) {
  10         position = position || 0;
  11         return this.indexOf(searchString, position) === position;
  12     };
  13 }
  14 if (!String.prototype.endsWith) {
  15     String.prototype.endsWith = function(suffix, length) {
  16         var l = length || this.length;
  17         return this.indexOf(suffix, l - suffix.length) !== -1;
  18     };
  19 }
  20
  21 if (!DOMTokenList.prototype.add) {
  22     DOMTokenList.prototype.add = function(className) {
  23         if (className && !hasClass(this, className)) {
  24             if (this.className && this.className.length > 0) {
  25                 this.className += " " + className;
  26             } else {
  27                 this.className = className;
  28             }
  29         }
  30     };
  31 }
  32
  33 if (!DOMTokenList.prototype.remove) {
  34     DOMTokenList.prototype.remove = function(className) {
  35         if (className && this.className) {
  36             this.className = (" " + this.className + " ").replace(" " + className + " ", " ")
  37                                                          .trim();
  38         }
  39     };
  40 }
  41
  42 (function() {
  43     "use strict";
  44
  45     // This mapping table should match the discriminants of
  46     // `rustdoc::html::item_type::ItemType` type in Rust.
  47     var itemTypes = ["mod",
  48                      "externcrate",
  49                      "import",
  50                      "struct",
  51                      "enum",
  52                      "fn",
  53                      "type",
  54                      "static",
  55                      "trait",
  56                      "impl",
  57                      "tymethod",
  58                      "method",
  59                      "structfield",
  60                      "variant",
  61                      "macro",
  62                      "primitive",
  63                      "associatedtype",
  64                      "constant",
  65                      "associatedconstant",
  66                      "union",
  67                      "foreigntype",
  68                      "keyword",
  69                      "existential",
  70                      "attr",
  71                      "derive"];
  72
  73     var search_input = document.getElementsByClassName("search-input")[0];
  74
  75     // On the search screen, so you remain on the last tab you opened.
  76     //
  77     // 0 for "In Names"
  78     // 1 for "In Parameters"
  79     // 2 for "In Return Types"
  80     var currentTab = 0;
  81
  82     var themesWidth = null;
  83
  84     var titleBeforeSearch = document.title;
  85
  86     function getPageId() {
  87         var id = document.location.href.split("#")[1];
  88         if (id) {
  89             return id.split("?")[0].split("&")[0];
  90         }
  91         return null;
  92     }
  93
  94     function showSidebar() {
  95         var elems = document.getElementsByClassName("sidebar-elems")[0];
  96         if (elems) {
  97             addClass(elems, "show-it");
  98         }
  99         var sidebar = document.getElementsByClassName("sidebar")[0];
 100         if (sidebar) {
 101             addClass(sidebar, "mobile");
 102             var filler = document.getElementById("sidebar-filler");
 103             if (!filler) {
 104                 var div = document.createElement("div");
 105                 div.id = "sidebar-filler";
 106                 sidebar.appendChild(div);
 107             }
 108         }
 109         var themePicker = document.getElementsByClassName("theme-picker");
 110         if (themePicker && themePicker.length > 0) {
 111             themePicker[0].style.display = "none";
 112         }
 113     }
 114
 115     function hideSidebar() {
 116         var elems = document.getElementsByClassName("sidebar-elems")[0];
 117         if (elems) {
 118             removeClass(elems, "show-it");
 119         }
 120         var sidebar = document.getElementsByClassName("sidebar")[0];
 121         removeClass(sidebar, "mobile");
 122         var filler = document.getElementById("sidebar-filler");
 123         if (filler) {
 124             filler.remove();
 125         }
 126         document.getElementsByTagName("body")[0].style.marginTop = "";
 127         var themePicker = document.getElementsByClassName("theme-picker");
 128         if (themePicker && themePicker.length > 0) {
 129             themePicker[0].style.display = null;
 130         }
 131     }
 132
 133     // used for special search precedence
 134     var TY_PRIMITIVE = itemTypes.indexOf("primitive");
 135     var TY_KEYWORD = itemTypes.indexOf("keyword");
 136
 137     onEachLazy(document.getElementsByClassName("js-only"), function(e) {
 138         removeClass(e, "js-only");
 139     });
 140
 141     function getQueryStringParams() {
 142         var params = {};
 143         window.location.search.substring(1).split("&").
 144             map(function(s) {
 145                 var pair = s.split("=");
 146                 params[decodeURIComponent(pair[0])] =
 147                     typeof pair[1] === "undefined" ? null : decodeURIComponent(pair[1]);
 148             });
 149         return params;
 150     }
 151
 152     function browserSupportsHistoryApi() {
 153         return window.history && typeof window.history.pushState === "function";
 154     }
 155
 156     var main = document.getElementById("main");
 157
 158     function highlightSourceLines(ev) {
 159         // If we're in mobile mode, we should add the sidebar in any case.
 160         hideSidebar();
 161         var elem;
 162         var search = document.getElementById("search");
 163         var i, from, to, match = window.location.hash.match(/^#?(\d+)(?:-(\d+))?$/);
 164         if (match) {
 165             from = parseInt(match[1], 10);
 166             to = Math.min(50000, parseInt(match[2] || match[1], 10));
 167             from = Math.min(from, to);
 168             elem = document.getElementById(from);
 169             if (!elem) {
 170                 return;
 171             }
 172             if (ev === null) {
 173                 var x = document.getElementById(from);
 174                 if (x) {
 175                     x.scrollIntoView();
 176                 }
 177             }
 178             onEachLazy(document.getElementsByClassName("line-numbers"), function(e) {
 179                 onEachLazy(e.getElementsByTagName("span"), function(i_e) {
 180                     removeClass(i_e, "line-highlighted");
 181                 });
 182             });
 183             for (i = from; i <= to; ++i) {
 184                 addClass(document.getElementById(i), "line-highlighted");
 185             }
 186         } else if (ev !== null && search && !hasClass(search, "hidden") && ev.newURL) {
 187             addClass(search, "hidden");
 188             removeClass(main, "hidden");
 189             var hash = ev.newURL.slice(ev.newURL.indexOf("#") + 1);
 190             if (browserSupportsHistoryApi()) {
 191                 history.replaceState(hash, "", "?search=#" + hash);
 192             }
 193             elem = document.getElementById(hash);
 194             if (elem) {
 195                 elem.scrollIntoView();
 196             }
 197         }
 198     }
 199
 200     function expandSection(id) {
 201         var elem = document.getElementById(id);
 202         if (elem && isHidden(elem)) {
 203             var h3 = elem.parentNode.previousElementSibling;
 204             if (h3 && h3.tagName !== "H3") {
 205                 h3 = h3.previousElementSibling; // skip div.docblock
 206             }
 207
 208             if (h3) {
 209                 var collapses = h3.getElementsByClassName("collapse-toggle");
 210                 if (collapses.length > 0) {
 211                     // The element is not visible, we need to make it appear!
 212                     collapseDocs(collapses[0], "show");
 213                 }
 214             }
 215         }
 216     }
 217
 218     highlightSourceLines(null);
 219     window.onhashchange = highlightSourceLines;
 220
 221     // Gets the human-readable string for the virtual-key code of the
 222     // given KeyboardEvent, ev.
 223     //
 224     // This function is meant as a polyfill for KeyboardEvent#key,
 225     // since it is not supported in Trident.  We also test for
 226     // KeyboardEvent#keyCode because the handleShortcut handler is
 227     // also registered for the keydown event, because Blink doesn't fire
 228     // keypress on hitting the Escape key.
 229     //
 230     // So I guess you could say things are getting pretty interoperable.
 231     function getVirtualKey(ev) {
 232         if ("key" in ev && typeof ev.key != "undefined") {
 233             return ev.key;
 234         }
 235
 236         var c = ev.charCode || ev.keyCode;
 237         if (c == 27) {
 238             return "Escape";
 239         }
 240         return String.fromCharCode(c);
 241     }
 242
 243     function displayHelp(display, ev) {
 244         if (display === true) {
 245             if (hasClass(help, "hidden")) {
 246                 ev.preventDefault();
 247                 removeClass(help, "hidden");
 248                 addClass(document.body, "blur");
 249             }
 250         } else if (hasClass(help, "hidden") === false) {
 251             ev.preventDefault();
 252             addClass(help, "hidden");
 253             removeClass(document.body, "blur");
 254         }
 255     }
 256
 257     function handleEscape(ev, help) {
 258         hideModal();
 259         var search = document.getElementById("search");
 260         if (hasClass(help, "hidden") === false) {
 261             displayHelp(false, ev);
 262         } else if (hasClass(search, "hidden") === false) {
 263             ev.preventDefault();
 264             addClass(search, "hidden");
 265             removeClass(main, "hidden");
 266             document.title = titleBeforeSearch;
 267         }
 268         defocusSearchBar();
 269     }
 270
 271     function handleShortcut(ev) {
 272         // Don't interfere with browser shortcuts
 273         if (ev.ctrlKey || ev.altKey || ev.metaKey) {
 274             return;
 275         }
 276
 277         var help = document.getElementById("help");
 278         if (document.activeElement.tagName === "INPUT") {
 279             switch (getVirtualKey(ev)) {
 280             case "Escape":
 281                 handleEscape(ev, help);
 282                 break;
 283             }
 284         } else {
 285             switch (getVirtualKey(ev)) {
 286             case "Escape":
 287                 handleEscape(ev, help);
 288                 break;
 289
 290             case "s":
 291             case "S":
 292                 displayHelp(false, ev);
 293                 hideModal();
 294                 ev.preventDefault();
 295                 focusSearchBar();
 296                 break;
 297
 298             case "+":
 299             case "-":
 300                 ev.preventDefault();
 301                 toggleAllDocs();
 302                 break;
 303
 304             case "?":
 305                 if (ev.shiftKey) {
 306                     hideModal();
 307                     displayHelp(true, ev);
 308                 }
 309                 break;
 310             }
 311         }
 312     }
 313
 314     function findParentElement(elem, tagName) {
 315         do {
 316             if (elem && elem.tagName === tagName) {
 317                 return elem;
 318             }
 319             elem = elem.parentNode;
 320         } while (elem);
 321         return null;
 322     }
 323
 324     document.onkeypress = handleShortcut;
 325     document.onkeydown = handleShortcut;
 326     document.onclick = function(ev) {
 327         if (hasClass(ev.target, "collapse-toggle")) {
 328             collapseDocs(ev.target, "toggle");
 329         } else if (hasClass(ev.target.parentNode, "collapse-toggle")) {
 330             collapseDocs(ev.target.parentNode, "toggle");
 331         } else if (ev.target.tagName === "SPAN" && hasClass(ev.target.parentNode, "line-numbers")) {
 332             var prev_id = 0;
 333
 334             var set_fragment = function(name) {
 335                 if (browserSupportsHistoryApi()) {
 336                     history.replaceState(null, null, "#" + name);
 337                     window.hashchange();
 338                 } else {
 339                     location.replace("#" + name);
 340                 }
 341             };
 342
 343             var cur_id = parseInt(ev.target.id, 10);
 344
 345             if (ev.shiftKey && prev_id) {
 346                 if (prev_id > cur_id) {
 347                     var tmp = prev_id;
 348                     prev_id = cur_id;
 349                     cur_id = tmp;
 350                 }
 351
 352                 set_fragment(prev_id + "-" + cur_id);
 353             } else {
 354                 prev_id = cur_id;
 355
 356                 set_fragment(cur_id);
 357             }
 358         } else if (hasClass(document.getElementById("help"), "hidden") === false) {
 359             addClass(document.getElementById("help"), "hidden");
 360             removeClass(document.body, "blur");
 361         } else {
 362             // Making a collapsed element visible on onhashchange seems
 363             // too late
 364             var a = findParentElement(ev.target, "A");
 365             if (a && a.hash) {
 366                 expandSection(a.hash.replace(/^#/, ""));
 367             }
 368         }
 369     };
 370
 371     var x = document.getElementsByClassName("version-selector");
 372     if (x.length > 0) {
 373         x[0].onchange = function() {
 374             var i, match,
 375                 url = document.location.href,
 376                 stripped = "",
 377                 len = rootPath.match(/\.\.\//g).length + 1;
 378
 379             for (i = 0; i < len; ++i) {
 380                 match = url.match(/\/[^\/]*$/);
 381                 if (i < len - 1) {
 382                     stripped = match[0] + stripped;
 383                 }
 384                 url = url.substring(0, url.length - match[0].length);
 385             }
 386
 387             url += "/" + document.getElementsByClassName("version-selector")[0].value + stripped;
 388
 389             document.location.href = url;
 390         };
 391     }
 392
 393     /**
 394      * A function to compute the Levenshtein distance between two strings
 395      * Licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported
 396      * Full License can be found at http://creativecommons.org/licenses/by-sa/3.0/legalcode
 397      * This code is an unmodified version of the code written by Marco de Wit
 398      * and was found at http://stackoverflow.com/a/18514751/745719
 399      */
 400     var levenshtein_row2 = [];
 401     function levenshtein(s1, s2) {
 402         if (s1 === s2) {
 403             return 0;
 404         }
 405         var s1_len = s1.length, s2_len = s2.length;
 406         if (s1_len && s2_len) {
 407             var i1 = 0, i2 = 0, a, b, c, c2, row = levenshtein_row2;
 408             while (i1 < s1_len) {
 409                 row[i1] = ++i1;
 410             }
 411             while (i2 < s2_len) {
 412                 c2 = s2.charCodeAt(i2);
 413                 a = i2;
 414                 ++i2;
 415                 b = i2;
 416                 for (i1 = 0; i1 < s1_len; ++i1) {
 417                     c = a + (s1.charCodeAt(i1) !== c2 ? 1 : 0);
 418                     a = row[i1];
 419                     b = b < a ? (b < c ? b + 1 : c) : (a < c ? a + 1 : c);
 420                     row[i1] = b;
 421                 }
 422             }
 423             return b;
 424         }
 425         return s1_len + s2_len;
 426     }
 427
 428     function initSearch(rawSearchIndex) {
 429         var currentResults, index, searchIndex;
 430         var MAX_LEV_DISTANCE = 3;
 431         var MAX_RESULTS = 200;
 432         var GENERICS_DATA = 1;
 433         var NAME = 0;
 434         var INPUTS_DATA = 0;
 435         var OUTPUT_DATA = 1;
 436         var params = getQueryStringParams();
 437
 438         // Populate search bar with query string search term when provided,
 439         // but only if the input bar is empty. This avoid the obnoxious issue
 440         // where you start trying to do a search, and the index loads, and
 441         // suddenly your search is gone!
 442         if (search_input.value === "") {
 443             search_input.value = params.search || "";
 444         }
 445
 446         /**
 447          * Executes the query and builds an index of results
 448          * @param  {[Object]} query      [The user query]
 449          * @param  {[type]} searchWords  [The list of search words to query
 450          *                                against]
 451          * @param  {[type]} filterCrates [Crate to search in if defined]
 452          * @return {[type]}              [A search index of results]
 453          */
 454         function execQuery(query, searchWords, filterCrates) {
 455             function itemTypeFromName(typename) {
 456                 var length = itemTypes.length;
 457                 for (var i = 0; i < length; ++i) {
 458                     if (itemTypes[i] === typename) {
 459                         return i;
 460                     }
 461                 }
 462                 return -1;
 463             }
 464
 465             var valLower = query.query.toLowerCase(),
 466                 val = valLower,
 467                 typeFilter = itemTypeFromName(query.type),
 468                 results = {}, results_in_args = {}, results_returned = {},
 469                 split = valLower.split("::");
 470
 471             var length = split.length;
 472             for (var z = 0; z < length; ++z) {
 473                 if (split[z] === "") {
 474                     split.splice(z, 1);
 475                     z -= 1;
 476                 }
 477             }
 478
 479             function transformResults(results, isType) {
 480                 var out = [];
 481                 var length = results.length;
 482                 for (var i = 0; i < length; ++i) {
 483                     if (results[i].id > -1) {
 484                         var obj = searchIndex[results[i].id];
 485                         obj.lev = results[i].lev;
 486                         if (isType !== true || obj.type) {
 487                             var res = buildHrefAndPath(obj);
 488                             obj.displayPath = pathSplitter(res[0]);
 489                             obj.fullPath = obj.displayPath + obj.name;
 490                             // To be sure than it some items aren't considered as duplicate.
 491                             obj.fullPath += "|" + obj.ty;
 492                             obj.href = res[1];
 493                             out.push(obj);
 494                             if (out.length >= MAX_RESULTS) {
 495                                 break;
 496                             }
 497                         }
 498                     }
 499                 }
 500                 return out;
 501             }
 502
 503             function sortResults(results, isType) {
 504                 var ar = [];
 505                 for (var entry in results) {
 506                     if (results.hasOwnProperty(entry)) {
 507                         ar.push(results[entry]);
 508                     }
 509                 }
 510                 results = ar;
 511                 var i;
 512                 var nresults = results.length;
 513                 for (i = 0; i < nresults; ++i) {
 514                     results[i].word = searchWords[results[i].id];
 515                     results[i].item = searchIndex[results[i].id] || {};
 516                 }
 517                 // if there are no results then return to default and fail
 518                 if (results.length === 0) {
 519                     return [];
 520                 }
 521
 522                 results.sort(function(aaa, bbb) {
 523                     var a, b;
 524
 525                     // Sort by non levenshtein results and then levenshtein results by the distance
 526                     // (less changes required to match means higher rankings)
 527                     a = (aaa.lev);
 528                     b = (bbb.lev);
 529                     if (a !== b) { return a - b; }
 530
 531                     // sort by crate (non-current crate goes later)
 532                     a = (aaa.item.crate !== window.currentCrate);
 533                     b = (bbb.item.crate !== window.currentCrate);
 534                     if (a !== b) { return a - b; }
 535
 536                     // sort by exact match (mismatch goes later)
 537                     a = (aaa.word !== valLower);
 538                     b = (bbb.word !== valLower);
 539                     if (a !== b) { return a - b; }
 540
 541                     // sort by item name length (longer goes later)
 542                     a = aaa.word.length;
 543                     b = bbb.word.length;
 544                     if (a !== b) { return a - b; }
 545
 546                     // sort by item name (lexicographically larger goes later)
 547                     a = aaa.word;
 548                     b = bbb.word;
 549                     if (a !== b) { return (a > b ? +1 : -1); }
 550
 551                     // sort by index of keyword in item name (no literal occurrence goes later)
 552                     a = (aaa.index < 0);
 553                     b = (bbb.index < 0);
 554                     if (a !== b) { return a - b; }
 555                     // (later literal occurrence, if any, goes later)
 556                     a = aaa.index;
 557                     b = bbb.index;
 558                     if (a !== b) { return a - b; }
 559
 560                     // special precedence for primitive and keyword pages
 561                     if ((aaa.item.ty === TY_PRIMITIVE && bbb.item.ty !== TY_KEYWORD) ||
 562                         (aaa.item.ty === TY_KEYWORD && bbb.item.ty !== TY_PRIMITIVE)) {
 563                         return -1;
 564                     }
 565                     if ((bbb.item.ty === TY_PRIMITIVE && aaa.item.ty !== TY_PRIMITIVE) ||
 566                         (bbb.item.ty === TY_KEYWORD && aaa.item.ty !== TY_KEYWORD)) {
 567                         return 1;
 568                     }
 569
 570                     // sort by description (no description goes later)
 571                     a = (aaa.item.desc === "");
 572                     b = (bbb.item.desc === "");
 573                     if (a !== b) { return a - b; }
 574
 575                     // sort by type (later occurrence in `itemTypes` goes later)
 576                     a = aaa.item.ty;
 577                     b = bbb.item.ty;
 578                     if (a !== b) { return a - b; }
 579
 580                     // sort by path (lexicographically larger goes later)
 581                     a = aaa.item.path;
 582                     b = bbb.item.path;
 583                     if (a !== b) { return (a > b ? +1 : -1); }
 584
 585                     // que sera, sera
 586                     return 0;
 587                 });
 588
 589                 var length = results.length;
 590                 for (i = 0; i < length; ++i) {
 591                     var result = results[i];
 592
 593                     // this validation does not make sense when searching by types
 594                     if (result.dontValidate) {
 595                         continue;
 596                     }
 597                     var name = result.item.name.toLowerCase(),
 598                         path = result.item.path.toLowerCase(),
 599                         parent = result.item.parent;
 600
 601                     if (isType !== true &&
 602                         validateResult(name, path, split, parent) === false)
 603                     {
 604                         result.id = -1;
 605                     }
 606                 }
 607                 return transformResults(results);
 608             }
 609
 610             function extractGenerics(val) {
 611                 val = val.toLowerCase();
 612                 if (val.indexOf("<") !== -1) {
 613                     var values = val.substring(val.indexOf("<") + 1, val.lastIndexOf(">"));
 614                     return {
 615                         name: val.substring(0, val.indexOf("<")),
 616                         generics: values.split(/\s*,\s*/),
 617                     };
 618                 }
 619                 return {
 620                     name: val,
 621                     generics: [],
 622                 };
 623             }
 624
 625             function checkGenerics(obj, val) {
 626                 // The names match, but we need to be sure that all generics kinda
 627                 // match as well.
 628                 var lev_distance = MAX_LEV_DISTANCE + 1;
 629                 if (val.generics.length > 0) {
 630                     if (obj.length > GENERICS_DATA &&
 631                           obj[GENERICS_DATA].length >= val.generics.length) {
 632                         var elems = obj[GENERICS_DATA].slice(0);
 633                         var total = 0;
 634                         var done = 0;
 635                         // We need to find the type that matches the most to remove it in order
 636                         // to move forward.
 637                         var vlength = val.generics.length;
 638                         for (var y = 0; y < vlength; ++y) {
 639                             var lev = { pos: -1, lev: MAX_LEV_DISTANCE + 1};
 640                             var elength = elems.length;
 641                             for (var x = 0; x < elength; ++x) {
 642                                 var tmp_lev = levenshtein(elems[x], val.generics[y]);
 643                                 if (tmp_lev < lev.lev) {
 644                                     lev.lev = tmp_lev;
 645                                     lev.pos = x;
 646                                 }
 647                             }
 648                             if (lev.pos !== -1) {
 649                                 elems.splice(lev.pos, 1);
 650                                 lev_distance = Math.min(lev.lev, lev_distance);
 651                                 total += lev.lev;
 652                                 done += 1;
 653                             } else {
 654                                 return MAX_LEV_DISTANCE + 1;
 655                             }
 656                         }
 657                         return lev_distance;//Math.ceil(total / done);
 658                     }
 659                 }
 660                 return MAX_LEV_DISTANCE + 1;
 661             }
 662
 663             // Check for type name and type generics (if any).
 664             function checkType(obj, val, literalSearch) {
 665                 var lev_distance = MAX_LEV_DISTANCE + 1;
 666                 var x;
 667                 if (obj[NAME] === val.name) {
 668                     if (literalSearch === true) {
 669                         if (val.generics && val.generics.length !== 0) {
 670                             if (obj.length > GENERICS_DATA &&
 671                                   obj[GENERICS_DATA].length >= val.generics.length) {
 672                                 var elems = obj[GENERICS_DATA].slice(0);
 673                                 var allFound = true;
 674
 675                                 for (var y = 0; allFound === true && y < val.generics.length; ++y) {
 676                                     allFound = false;
 677                                     for (x = 0; allFound === false && x < elems.length; ++x) {
 678                                         allFound = elems[x] === val.generics[y];
 679                                     }
 680                                     if (allFound === true) {
 681                                         elems.splice(x - 1, 1);
 682                                     }
 683                                 }
 684                                 if (allFound === true) {
 685                                     return true;
 686                                 }
 687                             } else {
 688                                 return false;
 689                             }
 690                         }
 691                         return true;
 692                     }
 693                     // If the type has generics but don't match, then it won't return at this point.
 694                     // Otherwise, `checkGenerics` will return 0 and it'll return.
 695                     if (obj.length > GENERICS_DATA && obj[GENERICS_DATA].length !== 0) {
 696                         var tmp_lev = checkGenerics(obj, val);
 697                         if (tmp_lev <= MAX_LEV_DISTANCE) {
 698                             return tmp_lev;
 699                         }
 700                     } else {
 701                         return 0;
 702                     }
 703                 }
 704                 // Names didn't match so let's check if one of the generic types could.
 705                 if (literalSearch === true) {
 706                      if (obj.length > GENERICS_DATA && obj[GENERICS_DATA].length > 0) {
 707                         var length = obj[GENERICS_DATA].length;
 708                         for (x = 0; x < length; ++x) {
 709                             if (obj[GENERICS_DATA][x] === val.name) {
 710                                 return true;
 711                             }
 712                         }
 713                     }
 714                     return false;
 715                 }
 716                 lev_distance = Math.min(levenshtein(obj[NAME], val.name), lev_distance);
 717                 if (lev_distance <= MAX_LEV_DISTANCE) {
 718                     lev_distance = Math.min(checkGenerics(obj, val), lev_distance);
 719                 } else if (obj.length > GENERICS_DATA && obj[GENERICS_DATA].length > 0) {
 720                     // We can check if the type we're looking for is inside the generics!
 721                     var olength = obj[GENERICS_DATA].length;
 722                     for (x = 0; x < olength; ++x) {
 723                         lev_distance = Math.min(levenshtein(obj[GENERICS_DATA][x], val.name),
 724                                                 lev_distance);
 725                     }
 726                 }
 727                 // Now whatever happens, the returned distance is "less good" so we should mark it
 728                 // as such, and so we add 1 to the distance to make it "less good".
 729                 return lev_distance + 1;
 730             }
 731
 732             function findArg(obj, val, literalSearch) {
 733                 var lev_distance = MAX_LEV_DISTANCE + 1;
 734
 735                 if (obj && obj.type && obj.type[INPUTS_DATA] &&
 736                       obj.type[INPUTS_DATA].length > 0) {
 737                     var length = obj.type[INPUTS_DATA].length;
 738                     for (var i = 0; i < length; i++) {
 739                         var tmp = checkType(obj.type[INPUTS_DATA][i], val, literalSearch);
 740                         if (literalSearch === true && tmp === true) {
 741                             return true;
 742                         }
 743                         lev_distance = Math.min(tmp, lev_distance);
 744                         if (lev_distance === 0) {
 745                             return 0;
 746                         }
 747                     }
 748                 }
 749                 return literalSearch === true ? false : lev_distance;
 750             }
 751
 752             function checkReturned(obj, val, literalSearch) {
 753                 var lev_distance = MAX_LEV_DISTANCE + 1;
 754
 755                 if (obj && obj.type && obj.type.length > OUTPUT_DATA) {
 756                     var tmp = checkType(obj.type[OUTPUT_DATA], val, literalSearch);
 757                     if (literalSearch === true && tmp === true) {
 758                         return true;
 759                     }
 760                     lev_distance = Math.min(tmp, lev_distance);
 761                     if (lev_distance === 0) {
 762                         return 0;
 763                     }
 764                 }
 765                 return literalSearch === true ? false : lev_distance;
 766             }
 767
 768             function checkPath(contains, lastElem, ty) {
 769                 if (contains.length === 0) {
 770                     return 0;
 771                 }
 772                 var ret_lev = MAX_LEV_DISTANCE + 1;
 773                 var path = ty.path.split("::");
 774
 775                 if (ty.parent && ty.parent.name) {
 776                     path.push(ty.parent.name.toLowerCase());
 777                 }
 778
 779                 var length = path.length;
 780                 var clength = contains.length;
 781                 if (clength > length) {
 782                     return MAX_LEV_DISTANCE + 1;
 783                 }
 784                 for (var i = 0; i < length; ++i) {
 785                     if (i + clength > length) {
 786                         break;
 787                     }
 788                     var lev_total = 0;
 789                     var aborted = false;
 790                     for (var x = 0; x < clength; ++x) {
 791                         var lev = levenshtein(path[i + x], contains[x]);
 792                         if (lev > MAX_LEV_DISTANCE) {
 793                             aborted = true;
 794                             break;
 795                         }
 796                         lev_total += lev;
 797                     }
 798                     if (aborted === false) {
 799                         ret_lev = Math.min(ret_lev, Math.round(lev_total / clength));
 800                     }
 801                 }
 802                 return ret_lev;
 803             }
 804
 805             function typePassesFilter(filter, type) {
 806                 // No filter
 807                 if (filter < 0) return true;
 808
 809                 // Exact match
 810                 if (filter === type) return true;
 811
 812                 // Match related items
 813                 var name = itemTypes[type];
 814                 switch (itemTypes[filter]) {
 815                     case "constant":
 816                         return (name == "associatedconstant");
 817                     case "fn":
 818                         return (name == "method" || name == "tymethod");
 819                     case "type":
 820                         return (name == "primitive" || name == "keyword");
 821                 }
 822
 823                 // No match
 824                 return false;
 825             }
 826
 827             function generateId(ty) {
 828                 if (ty.parent && ty.parent.name) {
 829                     return itemTypes[ty.ty] + ty.path + ty.parent.name + ty.name;
 830                 }
 831                 return itemTypes[ty.ty] + ty.path + ty.name;
 832             }
 833
 834             // quoted values mean literal search
 835             var nSearchWords = searchWords.length;
 836             var i;
 837             var ty;
 838             var fullId;
 839             var returned;
 840             var in_args;
 841             if ((val.charAt(0) === "\"" || val.charAt(0) === "'") &&
 842                 val.charAt(val.length - 1) === val.charAt(0))
 843             {
 844                 val = extractGenerics(val.substr(1, val.length - 2));
 845                 for (i = 0; i < nSearchWords; ++i) {
 846                     if (filterCrates !== undefined && searchIndex[i].crate !== filterCrates) {
 847                         continue;
 848                     }
 849                     in_args = findArg(searchIndex[i], val, true);
 850                     returned = checkReturned(searchIndex[i], val, true);
 851                     ty = searchIndex[i];
 852                     fullId = generateId(ty);
 853
 854                     if (searchWords[i] === val.name) {
 855                         // filter type: ... queries
 856                         if (typePassesFilter(typeFilter, searchIndex[i].ty) &&
 857                             results[fullId] === undefined)
 858                         {
 859                             results[fullId] = {id: i, index: -1};
 860                         }
 861                     } else if ((in_args === true || returned === true) &&
 862                                typePassesFilter(typeFilter, searchIndex[i].ty)) {
 863                         if (in_args === true || returned === true) {
 864                             if (in_args === true) {
 865                                 results_in_args[fullId] = {
 866                                     id: i,
 867                                     index: -1,
 868                                     dontValidate: true,
 869                                 };
 870                             }
 871                             if (returned === true) {
 872                                 results_returned[fullId] = {
 873                                     id: i,
 874                                     index: -1,
 875                                     dontValidate: true,
 876                                 };
 877                             }
 878                         } else {
 879                             results[fullId] = {
 880                                 id: i,
 881                                 index: -1,
 882                                 dontValidate: true,
 883                             };
 884                         }
 885                     }
 886                 }
 887                 query.inputs = [val];
 888                 query.output = val;
 889                 query.search = val;
 890             // searching by type
 891             } else if (val.search("->") > -1) {
 892                 var trimmer = function(s) { return s.trim(); };
 893                 var parts = val.split("->").map(trimmer);
 894                 var input = parts[0];
 895                 // sort inputs so that order does not matter
 896                 var inputs = input.split(",").map(trimmer).sort();
 897                 for (i = 0; i < inputs.length; ++i) {
 898                     inputs[i] = extractGenerics(inputs[i]);
 899                 }
 900                 var output = extractGenerics(parts[1]);
 901
 902                 for (i = 0; i < nSearchWords; ++i) {
 903                     if (filterCrates !== undefined && searchIndex[i].crate !== filterCrates) {
 904                         continue;
 905                     }
 906                     var type = searchIndex[i].type;
 907                     ty = searchIndex[i];
 908                     if (!type) {
 909                         continue;
 910                     }
 911                     fullId = generateId(ty);
 912
 913                     // allow searching for void (no output) functions as well
 914                     var typeOutput = type.length > OUTPUT_DATA ? type[OUTPUT_DATA].name : "";
 915                     returned = checkReturned(ty, output, true);
 916                     if (output.name === "*" || returned === true) {
 917                         in_args = false;
 918                         var module = false;
 919
 920                         if (input === "*") {
 921                             module = true;
 922                         } else {
 923                             var allFound = true;
 924                             for (var it = 0; allFound === true && it < inputs.length; it++) {
 925                                 allFound = checkType(type, inputs[it], true);
 926                             }
 927                             in_args = allFound;
 928                         }
 929                         if (in_args === true) {
 930                             results_in_args[fullId] = {
 931                                 id: i,
 932                                 index: -1,
 933                                 dontValidate: true,
 934                             };
 935                         }
 936                         if (returned === true) {
 937                             results_returned[fullId] = {
 938                                 id: i,
 939                                 index: -1,
 940                                 dontValidate: true,
 941                             };
 942                         }
 943                         if (module === true) {
 944                             results[fullId] = {
 945                                 id: i,
 946                                 index: -1,
 947                                 dontValidate: true,
 948                             };
 949                         }
 950                     }
 951                 }
 952                 query.inputs = inputs.map(function(input) {
 953                     return input.name;
 954                 });
 955                 query.output = output.name;
 956             } else {
 957                 query.inputs = [val];
 958                 query.output = val;
 959                 query.search = val;
 960                 // gather matching search results up to a certain maximum
 961                 val = val.replace(/\_/g, "");
 962
 963                 var valGenerics = extractGenerics(val);
 964
 965                 var paths = valLower.split("::");
 966                 var j;
 967                 for (j = 0; j < paths.length; ++j) {
 968                     if (paths[j] === "") {
 969                         paths.splice(j, 1);
 970                         j -= 1;
 971                     }
 972                 }
 973                 val = paths[paths.length - 1];
 974                 var contains = paths.slice(0, paths.length > 1 ? paths.length - 1 : 1);
 975
 976                 for (j = 0; j < nSearchWords; ++j) {
 977                     var lev;
 978                     var lev_distance;
 979                     ty = searchIndex[j];
 980                     if (!ty || (filterCrates !== undefined && ty.crate !== filterCrates)) {
 981                         continue;
 982                     }
 983                     var lev_distance;
 984                     var lev_add = 0;
 985                     if (paths.length > 1) {
 986                         lev = checkPath(contains, paths[paths.length - 1], ty);
 987                         if (lev > MAX_LEV_DISTANCE) {
 988                             continue;
 989                         } else if (lev > 0) {
 990                             lev_add = 1;
 991                         }
 992                     }
 993
 994                     returned = MAX_LEV_DISTANCE + 1;
 995                     in_args = MAX_LEV_DISTANCE + 1;
 996                     var index = -1;
 997                     // we want lev results to go lower than others
 998                     lev = MAX_LEV_DISTANCE + 1;
 999                     fullId = generateId(ty);
1000
1001                     if (searchWords[j].indexOf(split[i]) > -1 ||
1002                         searchWords[j].indexOf(val) > -1 ||
1003                         searchWords[j].replace(/_/g, "").indexOf(val) > -1)
1004                     {
1005                         // filter type: ... queries
1006                         if (typePassesFilter(typeFilter, ty.ty) && results[fullId] === undefined) {
1007                             index = searchWords[j].replace(/_/g, "").indexOf(val);
1008                         }
1009                     }
1010                     if ((lev = levenshtein(searchWords[j], val)) <= MAX_LEV_DISTANCE) {
1011                         if (typePassesFilter(typeFilter, ty.ty) === false) {
1012                             lev = MAX_LEV_DISTANCE + 1;
1013                         } else {
1014                             lev += 1;
1015                         }
1016                     }
1017                     if ((in_args = findArg(ty, valGenerics)) <= MAX_LEV_DISTANCE) {
1018                         if (typePassesFilter(typeFilter, ty.ty) === false) {
1019                             in_args = MAX_LEV_DISTANCE + 1;
1020                         }
1021                     }
1022                     if ((returned = checkReturned(ty, valGenerics)) <= MAX_LEV_DISTANCE) {
1023                         if (typePassesFilter(typeFilter, ty.ty) === false) {
1024                             returned = MAX_LEV_DISTANCE + 1;
1025                         }
1026                     }
1027
1028                     lev += lev_add;
1029                     if (lev > 0 && val.length > 3 && searchWords[j].indexOf(val) > -1) {
1030                         if (val.length < 6) {
1031                             lev -= 1;
1032                         } else {
1033                             lev = 0;
1034                         }
1035                     }
1036                     if (in_args <= MAX_LEV_DISTANCE) {
1037                         if (results_in_args[fullId] === undefined) {
1038                             results_in_args[fullId] = {
1039                                 id: j,
1040                                 index: index,
1041                                 lev: in_args,
1042                             };
1043                         }
1044                         results_in_args[fullId].lev =
1045                             Math.min(results_in_args[fullId].lev, in_args);
1046                     }
1047                     if (returned <= MAX_LEV_DISTANCE) {
1048                         if (results_returned[fullId] === undefined) {
1049                             results_returned[fullId] = {
1050                                 id: j,
1051                                 index: index,
1052                                 lev: returned,
1053                             };
1054                         }
1055                         results_returned[fullId].lev =
1056                             Math.min(results_returned[fullId].lev, returned);
1057                     }
1058                     if (index !== -1 || lev <= MAX_LEV_DISTANCE) {
1059                         if (index !== -1 && paths.length < 2) {
1060                             lev = 0;
1061                         }
1062                         if (results[fullId] === undefined) {
1063                             results[fullId] = {
1064                                 id: j,
1065                                 index: index,
1066                                 lev: lev,
1067                             };
1068                         }
1069                         results[fullId].lev = Math.min(results[fullId].lev, lev);
1070                     }
1071                 }
1072             }
1073
1074             var ret = {
1075                 "in_args": sortResults(results_in_args, true),
1076                 "returned": sortResults(results_returned, true),
1077                 "others": sortResults(results),
1078             };
1079             if (ALIASES && ALIASES[window.currentCrate] &&
1080                     ALIASES[window.currentCrate][query.raw]) {
1081                 var aliases = ALIASES[window.currentCrate][query.raw];
1082                 for (i = 0; i < aliases.length; ++i) {
1083                     aliases[i].is_alias = true;
1084                     aliases[i].alias = query.raw;
1085                     aliases[i].path = aliases[i].p;
1086                     var res = buildHrefAndPath(aliases[i]);
1087                     aliases[i].displayPath = pathSplitter(res[0]);
1088                     aliases[i].fullPath = aliases[i].displayPath + aliases[i].name;
1089                     aliases[i].href = res[1];
1090                     ret.others.unshift(aliases[i]);
1091                     if (ret.others.length > MAX_RESULTS) {
1092                         ret.others.pop();
1093                     }
1094                 }
1095             }
1096             return ret;
1097         }
1098
1099         /**
1100          * Validate performs the following boolean logic. For example:
1101          * "File::open" will give IF A PARENT EXISTS => ("file" && "open")
1102          * exists in (name || path || parent) OR => ("file" && "open") exists in
1103          * (name || path )
1104          *
1105          * This could be written functionally, but I wanted to minimise
1106          * functions on stack.
1107          *
1108          * @param  {[string]} name   [The name of the result]
1109          * @param  {[string]} path   [The path of the result]
1110          * @param  {[string]} keys   [The keys to be used (["file", "open"])]
1111          * @param  {[object]} parent [The parent of the result]
1112          * @return {[boolean]}       [Whether the result is valid or not]
1113          */
1114         function validateResult(name, path, keys, parent) {
1115             for (var i = 0; i < keys.length; ++i) {
1116                 // each check is for validation so we negate the conditions and invalidate
1117                 if (!(
1118                     // check for an exact name match
1119                     name.indexOf(keys[i]) > -1 ||
1120                     // then an exact path match
1121                     path.indexOf(keys[i]) > -1 ||
1122                     // next if there is a parent, check for exact parent match
1123                     (parent !== undefined &&
1124                         parent.name.toLowerCase().indexOf(keys[i]) > -1) ||
1125                     // lastly check to see if the name was a levenshtein match
1126                     levenshtein(name, keys[i]) <= MAX_LEV_DISTANCE)) {
1127                     return false;
1128                 }
1129             }
1130             return true;
1131         }
1132
1133         function getQuery(raw) {
1134             var matches, type, query;
1135             query = raw;
1136
1137             matches = query.match(/^(fn|mod|struct|enum|trait|type|const|macro)\s*:\s*/i);
1138             if (matches) {
1139                 type = matches[1].replace(/^const$/, "constant");
1140                 query = query.substring(matches[0].length);
1141             }
1142
1143             return {
1144                 raw: raw,
1145                 query: query,
1146                 type: type,
1147                 id: query + type
1148             };
1149         }
1150
1151         function initSearchNav() {
1152             var hoverTimeout;
1153
1154             var click_func = function(e) {
1155                 var el = e.target;
1156                 // to retrieve the real "owner" of the event.
1157                 while (el.tagName !== "TR") {
1158                     el = el.parentNode;
1159                 }
1160                 var dst = e.target.getElementsByTagName("a");
1161                 if (dst.length < 1) {
1162                     return;
1163                 }
1164                 dst = dst[0];
1165                 if (window.location.pathname === dst.pathname) {
1166                     addClass(document.getElementById("search"), "hidden");
1167                     removeClass(main, "hidden");
1168                     document.location.href = dst.href;
1169                 }
1170             };
1171             var mouseover_func = function(e) {
1172                 var el = e.target;
1173                 // to retrieve the real "owner" of the event.
1174                 while (el.tagName !== "TR") {
1175                     el = el.parentNode;
1176                 }
1177                 clearTimeout(hoverTimeout);
1178                 hoverTimeout = setTimeout(function() {
1179                     onEachLazy(document.getElementsByClassName("search-results"), function(e) {
1180                         onEachLazy(e.getElementsByClassName("result"), function(i_e) {
1181                             removeClass(i_e, "highlighted");
1182                         });
1183                     });
1184                     addClass(el, "highlighted");
1185                 }, 20);
1186             };
1187             onEachLazy(document.getElementsByClassName("search-results"), function(e) {
1188                 onEachLazy(e.getElementsByClassName("result"), function(i_e) {
1189                     i_e.onclick = click_func;
1190                     i_e.onmouseover = mouseover_func;
1191                 });
1192             });
1193
1194             search_input.onkeydown = function(e) {
1195                 // "actives" references the currently highlighted item in each search tab.
1196                 // Each array in "actives" represents a tab.
1197                 var actives = [[], [], []];
1198                 // "current" is used to know which tab we're looking into.
1199                 var current = 0;
1200                 onEachLazy(document.getElementsByClassName("search-results"), function(e) {
1201                     onEachLazy(e.getElementsByClassName("highlighted"), function(e) {
1202                         actives[current].push(e);
1203                     });
1204                     current += 1;
1205                 });
1206
1207                 if (e.which === 38) { // up
1208                     if (!actives[currentTab].length ||
1209                         !actives[currentTab][0].previousElementSibling) {
1210                         return;
1211                     }
1212
1213                     addClass(actives[currentTab][0].previousElementSibling, "highlighted");
1214                     removeClass(actives[currentTab][0], "highlighted");
1215                 } else if (e.which === 40) { // down
1216                     if (!actives[currentTab].length) {
1217                         var results = document.getElementsByClassName("search-results");
1218                         if (results.length > 0) {
1219                             var res = results[currentTab].getElementsByClassName("result");
1220                             if (res.length > 0) {
1221                                 addClass(res[0], "highlighted");
1222                             }
1223                         }
1224                     } else if (actives[currentTab][0].nextElementSibling) {
1225                         addClass(actives[currentTab][0].nextElementSibling, "highlighted");
1226                         removeClass(actives[currentTab][0], "highlighted");
1227                     }
1228                 } else if (e.which === 13) { // return
1229                     if (actives[currentTab].length) {
1230                         document.location.href =
1231                             actives[currentTab][0].getElementsByTagName("a")[0].href;
1232                     }
1233                 } else if (e.which === 9) { // tab
1234                     if (e.shiftKey) {
1235                         printTab(currentTab > 0 ? currentTab - 1 : 2);
1236                     } else {
1237                         printTab(currentTab > 1 ? 0 : currentTab + 1);
1238                     }
1239                     e.preventDefault();
1240                 } else if (e.which === 16) { // shift
1241                     // Does nothing, it's just to avoid losing "focus" on the highlighted element.
1242                 } else if (e.which === 27) { // escape
1243                     removeClass(actives[currentTab][0], "highlighted");
1244                     search_input.value = "";
1245                     defocusSearchBar();
1246                 } else if (actives[currentTab].length > 0) {
1247                     removeClass(actives[currentTab][0], "highlighted");
1248                 }
1249             };
1250         }
1251
1252         function buildHrefAndPath(item) {
1253             var displayPath;
1254             var href;
1255             var type = itemTypes[item.ty];
1256             var name = item.name;
1257
1258             if (type === "mod") {
1259                 displayPath = item.path + "::";
1260                 href = rootPath + item.path.replace(/::/g, "/") + "/" +
1261                        name + "/index.html";
1262             } else if (type === "primitive" || type === "keyword") {
1263                 displayPath = "";
1264                 href = rootPath + item.path.replace(/::/g, "/") +
1265                        "/" + type + "." + name + ".html";
1266             } else if (type === "externcrate") {
1267                 displayPath = "";
1268                 href = rootPath + name + "/index.html";
1269             } else if (item.parent !== undefined) {
1270                 var myparent = item.parent;
1271                 var anchor = "#" + type + "." + name;
1272                 var parentType = itemTypes[myparent.ty];
1273                 if (parentType === "primitive") {
1274                     displayPath = myparent.name + "::";
1275                 } else {
1276                     displayPath = item.path + "::" + myparent.name + "::";
1277                 }
1278                 href = rootPath + item.path.replace(/::/g, "/") +
1279                        "/" + parentType +
1280                        "." + myparent.name +
1281                        ".html" + anchor;
1282             } else {
1283                 displayPath = item.path + "::";
1284                 href = rootPath + item.path.replace(/::/g, "/") +
1285                        "/" + type + "." + name + ".html";
1286             }
1287             return [displayPath, href];
1288         }
1289
1290         function escape(content) {
1291             var h1 = document.createElement("h1");
1292             h1.textContent = content;
1293             return h1.innerHTML;
1294         }
1295
1296         function pathSplitter(path) {
1297             var tmp = "<span>" + path.replace(/::/g, "::</span><span>");
1298             if (tmp.endsWith("<span>")) {
1299                 return tmp.slice(0, tmp.length - 6);
1300             }
1301             return tmp;
1302         }
1303
1304         function addTab(array, query, display) {
1305             var extraStyle = "";
1306             if (display === false) {
1307                 extraStyle = " style=\"display: none;\"";
1308             }
1309
1310             var output = "";
1311             var duplicates = {};
1312             var length = 0;
1313             if (array.length > 0) {
1314                 output = "<table class=\"search-results\"" + extraStyle + ">";
1315
1316                 array.forEach(function(item) {
1317                     var name, type;
1318
1319                     name = item.name;
1320                     type = itemTypes[item.ty];
1321
1322                     if (item.is_alias !== true) {
1323                         if (duplicates[item.fullPath]) {
1324                             return;
1325                         }
1326                         duplicates[item.fullPath] = true;
1327                     }
1328                     length += 1;
1329
1330                     output += "<tr class=\"" + type + " result\"><td>" +
1331                               "<a href=\"" + item.href + "\">" +
1332                               (item.is_alias === true ?
1333                                ("<span class=\"alias\"><b>" + item.alias + " </b></span><span " +
1334                                   "class=\"grey\"><i>&nbsp;- see&nbsp;</i></span>") : "") +
1335                               item.displayPath + "<span class=\"" + type + "\">" +
1336                               name + "</span></a></td><td>" +
1337                               "<a href=\"" + item.href + "\">" +
1338                               "<span class=\"desc\">" + escape(item.desc) +
1339                               "&nbsp;</span></a></td></tr>";
1340                 });
1341                 output += "</table>";
1342             } else {
1343                 output = "<div class=\"search-failed\"" + extraStyle + ">No results :(<br/>" +
1344                     "Try on <a href=\"https://duckduckgo.com/?q=" +
1345                     encodeURIComponent("rust " + query.query) +
1346                     "\">DuckDuckGo</a>?<br/><br/>" +
1347                     "Or try looking in one of these:<ul><li>The <a " +
1348                     "href=\"https://doc.rust-lang.org/reference/index.html\">Rust Reference</a> " +
1349                     " for technical details about the language.</li><li><a " +
1350                     "href=\"https://doc.rust-lang.org/rust-by-example/index.html\">Rust By " +
1351                     "Example</a> for expository code examples.</a></li><li>The <a " +
1352                     "href=\"https://doc.rust-lang.org/book/index.html\">Rust Book</a> for " +
1353                     "introductions to language features and the language itself.</li><li><a " +
1354                     "href=\"https://docs.rs\">Docs.rs</a> for documentation of crates released on" +
1355                     " <a href=\"https://crates.io/\">crates.io</a>.</li></ul></div>";
1356             }
1357             return [output, length];
1358         }
1359
1360         function makeTabHeader(tabNb, text, nbElems) {
1361             if (currentTab === tabNb) {
1362                 return "<div class=\"selected\">" + text +
1363                        " <div class=\"count\">(" + nbElems + ")</div></div>";
1364             }
1365             return "<div>" + text + " <div class=\"count\">(" + nbElems + ")</div></div>";
1366         }
1367
1368         function showResults(results) {
1369             if (results.others.length === 1 &&
1370                 getCurrentValue("rustdoc-go-to-only-result") === "true") {
1371                 var elem = document.createElement("a");
1372                 elem.href = results.others[0].href;
1373                 elem.style.display = "none";
1374                 // For firefox, we need the element to be in the DOM so it can be clicked.
1375                 document.body.appendChild(elem);
1376                 elem.click();
1377             }
1378             var query = getQuery(search_input.value);
1379
1380             currentResults = query.id;
1381
1382             var ret_others = addTab(results.others, query);
1383             var ret_in_args = addTab(results.in_args, query, false);
1384             var ret_returned = addTab(results.returned, query, false);
1385
1386             var output = "<h1>Results for " + escape(query.query) +
1387                 (query.type ? " (type: " + escape(query.type) + ")" : "") + "</h1>" +
1388                 "<div id=\"titles\">" +
1389                 makeTabHeader(0, "In Names", ret_others[1]) +
1390                 makeTabHeader(1, "In Parameters", ret_in_args[1]) +
1391                 makeTabHeader(2, "In Return Types", ret_returned[1]) +
1392                 "</div><div id=\"results\">" +
1393                 ret_others[0] + ret_in_args[0] + ret_returned[0] + "</div>";
1394
1395             addClass(main, "hidden");
1396             var search = document.getElementById("search");
1397             removeClass(search, "hidden");
1398             search.innerHTML = output;
1399             var tds = search.getElementsByTagName("td");
1400             var td_width = 0;
1401             if (tds.length > 0) {
1402                 td_width = tds[0].offsetWidth;
1403             }
1404             var width = search.offsetWidth - 40 - td_width;
1405             onEachLazy(search.getElementsByClassName("desc"), function(e) {
1406                 e.style.width = width + "px";
1407             });
1408             initSearchNav();
1409             var elems = document.getElementById("titles").childNodes;
1410             elems[0].onclick = function() { printTab(0); };
1411             elems[1].onclick = function() { printTab(1); };
1412             elems[2].onclick = function() { printTab(2); };
1413             printTab(currentTab);
1414         }
1415
1416         function execSearch(query, searchWords, filterCrates) {
1417             function getSmallest(arrays, positions, notDuplicates) {
1418                 var start = null;
1419
1420                 for (var it = 0; it < positions.length; ++it) {
1421                     if (arrays[it].length > positions[it] &&
1422                         (start === null || start > arrays[it][positions[it]].lev) &&
1423                         !notDuplicates[arrays[it][positions[it]].fullPath]) {
1424                         start = arrays[it][positions[it]].lev;
1425                     }
1426                 }
1427                 return start;
1428             }
1429
1430             function mergeArrays(arrays) {
1431                 var ret = [];
1432                 var positions = [];
1433                 var notDuplicates = {};
1434
1435                 for (var x = 0; x < arrays.length; ++x) {
1436                     positions.push(0);
1437                 }
1438                 while (ret.length < MAX_RESULTS) {
1439                     var smallest = getSmallest(arrays, positions, notDuplicates);
1440
1441                     if (smallest === null) {
1442                         break;
1443                     }
1444                     for (x = 0; x < arrays.length && ret.length < MAX_RESULTS; ++x) {
1445                         if (arrays[x].length > positions[x] &&
1446                                 arrays[x][positions[x]].lev === smallest &&
1447                                 !notDuplicates[arrays[x][positions[x]].fullPath]) {
1448                             ret.push(arrays[x][positions[x]]);
1449                             notDuplicates[arrays[x][positions[x]].fullPath] = true;
1450                             positions[x] += 1;
1451                         }
1452                     }
1453                 }
1454                 return ret;
1455             }
1456
1457             var queries = query.raw.split(",");
1458             var results = {
1459                 "in_args": [],
1460                 "returned": [],
1461                 "others": [],
1462             };
1463
1464             for (var i = 0; i < queries.length; ++i) {
1465                 query = queries[i].trim();
1466                 if (query.length !== 0) {
1467                     var tmp = execQuery(getQuery(query), searchWords, filterCrates);
1468
1469                     results.in_args.push(tmp.in_args);
1470                     results.returned.push(tmp.returned);
1471                     results.others.push(tmp.others);
1472                 }
1473             }
1474             if (queries.length > 1) {
1475                 return {
1476                     "in_args": mergeArrays(results.in_args),
1477                     "returned": mergeArrays(results.returned),
1478                     "others": mergeArrays(results.others),
1479                 };
1480             } else {
1481                 return {
1482                     "in_args": results.in_args[0],
1483                     "returned": results.returned[0],
1484                     "others": results.others[0],
1485                 };
1486             }
1487         }
1488
1489         function getFilterCrates() {
1490             var elem = document.getElementById("crate-search");
1491
1492             if (elem && elem.value !== "All crates" && rawSearchIndex.hasOwnProperty(elem.value)) {
1493                 return elem.value;
1494             }
1495             return undefined;
1496         }
1497
1498         function search(e, forced) {
1499             var params = getQueryStringParams();
1500             var query = getQuery(search_input.value.trim());
1501
1502             if (e) {
1503                 e.preventDefault();
1504             }
1505
1506             if (query.query.length === 0) {
1507                 return;
1508             }
1509             if (forced !== true && query.id === currentResults) {
1510                 if (query.query.length > 0) {
1511                     putBackSearch(search_input);
1512                 }
1513                 return;
1514             }
1515
1516             // Update document title to maintain a meaningful browser history
1517             document.title = "Results for " + query.query + " - Rust";
1518
1519             // Because searching is incremental by character, only the most
1520             // recent search query is added to the browser history.
1521             if (browserSupportsHistoryApi()) {
1522                 if (!history.state && !params.search) {
1523                     history.pushState(query, "", "?search=" + encodeURIComponent(query.raw));
1524                 } else {
1525                     history.replaceState(query, "", "?search=" + encodeURIComponent(query.raw));
1526                 }
1527             }
1528
1529             var filterCrates = getFilterCrates();
1530             showResults(execSearch(query, index, filterCrates), filterCrates);
1531         }
1532
1533         function buildIndex(rawSearchIndex) {
1534             searchIndex = [];
1535             var searchWords = [];
1536             var i;
1537
1538             for (var crate in rawSearchIndex) {
1539                 if (!rawSearchIndex.hasOwnProperty(crate)) { continue; }
1540
1541                 searchWords.push(crate);
1542                 searchIndex.push({
1543                     crate: crate,
1544                     ty: 1, // == ExternCrate
1545                     name: crate,
1546                     path: "",
1547                     desc: rawSearchIndex[crate].doc,
1548                     type: null,
1549                 });
1550
1551                 // an array of [(Number) item type,
1552                 //              (String) name,
1553                 //              (String) full path or empty string for previous path,
1554                 //              (String) description,
1555                 //              (Number | null) the parent path index to `paths`]
1556                 //              (Object | null) the type of the function (if any)
1557                 var items = rawSearchIndex[crate].i;
1558                 // an array of [(Number) item type,
1559                 //              (String) name]
1560                 var paths = rawSearchIndex[crate].p;
1561
1562                 // convert `paths` into an object form
1563                 var len = paths.length;
1564                 for (i = 0; i < len; ++i) {
1565                     paths[i] = {ty: paths[i][0], name: paths[i][1]};
1566                 }
1567
1568                 // convert `items` into an object form, and construct word indices.
1569                 //
1570                 // before any analysis is performed lets gather the search terms to
1571                 // search against apart from the rest of the data.  This is a quick
1572                 // operation that is cached for the life of the page state so that
1573                 // all other search operations have access to this cached data for
1574                 // faster analysis operations
1575                 len = items.length;
1576                 var lastPath = "";
1577                 for (i = 0; i < len; ++i) {
1578                     var rawRow = items[i];
1579                     var row = {crate: crate, ty: rawRow[0], name: rawRow[1],
1580                                path: rawRow[2] || lastPath, desc: rawRow[3],
1581                                parent: paths[rawRow[4]], type: rawRow[5]};
1582                     searchIndex.push(row);
1583                     if (typeof row.name === "string") {
1584                         var word = row.name.toLowerCase();
1585                         searchWords.push(word);
1586                     } else {
1587                         searchWords.push("");
1588                     }
1589                     lastPath = row.path;
1590                 }
1591             }
1592             return searchWords;
1593         }
1594
1595         function startSearch() {
1596             var searchTimeout;
1597             var callback = function() {
1598                 clearTimeout(searchTimeout);
1599                 if (search_input.value.length === 0) {
1600                     if (browserSupportsHistoryApi()) {
1601                         history.replaceState("", "std - Rust", "?search=");
1602                     }
1603                     if (hasClass(main, "content")) {
1604                         removeClass(main, "hidden");
1605                     }
1606                     var search_c = document.getElementById("search");
1607                     if (hasClass(search_c, "content")) {
1608                         addClass(search_c, "hidden");
1609                     }
1610                 } else {
1611                     searchTimeout = setTimeout(search, 500);
1612                 }
1613             };
1614             search_input.onkeyup = callback;
1615             search_input.oninput = callback;
1616             document.getElementsByClassName("search-form")[0].onsubmit = function(e) {
1617                 e.preventDefault();
1618                 clearTimeout(searchTimeout);
1619                 search();
1620             };
1621             search_input.onchange = function(e) {
1622                 // Do NOT e.preventDefault() here. It will prevent pasting.
1623                 clearTimeout(searchTimeout);
1624                 // zero-timeout necessary here because at the time of event handler execution the
1625                 // pasted content is not in the input field yet. Shouldn’t make any difference for
1626                 // change, though.
1627                 setTimeout(search, 0);
1628             };
1629             search_input.onpaste = search_input.onchange;
1630
1631             var selectCrate = document.getElementById('crate-search');
1632             if (selectCrate) {
1633                 selectCrate.onchange = function() {
1634                     search(undefined, true);
1635                 };
1636             }
1637
1638             // Push and pop states are used to add search results to the browser
1639             // history.
1640             if (browserSupportsHistoryApi()) {
1641                 // Store the previous <title> so we can revert back to it later.
1642                 var previousTitle = document.title;
1643
1644                 window.onpopstate = function(e) {
1645                     var params = getQueryStringParams();
1646                     // When browsing back from search results the main page
1647                     // visibility must be reset.
1648                     if (!params.search) {
1649                         if (hasClass(main, "content")) {
1650                             removeClass(main, "hidden");
1651                         }
1652                         var search_c = document.getElementById("search");
1653                         if (hasClass(search_c, "content")) {
1654                             addClass(search_c, "hidden");
1655                         }
1656                     }
1657                     // Revert to the previous title manually since the History
1658                     // API ignores the title parameter.
1659                     document.title = previousTitle;
1660                     // When browsing forward to search results the previous
1661                     // search will be repeated, so the currentResults are
1662                     // cleared to ensure the search is successful.
1663                     currentResults = null;
1664                     // Synchronize search bar with query string state and
1665                     // perform the search. This will empty the bar if there's
1666                     // nothing there, which lets you really go back to a
1667                     // previous state with nothing in the bar.
1668                     if (params.search) {
1669                         search_input.value = params.search;
1670                     } else {
1671                         search_input.value = "";
1672                     }
1673                     // Some browsers fire "onpopstate" for every page load
1674                     // (Chrome), while others fire the event only when actually
1675                     // popping a state (Firefox), which is why search() is
1676                     // called both here and at the end of the startSearch()
1677                     // function.
1678                     search();
1679                 };
1680             }
1681             search();
1682         }
1683
1684         index = buildIndex(rawSearchIndex);
1685         startSearch();
1686
1687         // Draw a convenient sidebar of known crates if we have a listing
1688         if (rootPath === "../" || rootPath === "./") {
1689             var sidebar = document.getElementsByClassName("sidebar-elems")[0];
1690             if (sidebar) {
1691                 var div = document.createElement("div");
1692                 div.className = "block crate";
1693                 div.innerHTML = "<h3>Crates</h3>";
1694                 var ul = document.createElement("ul");
1695                 div.appendChild(ul);
1696
1697                 var crates = [];
1698                 for (var crate in rawSearchIndex) {
1699                     if (!rawSearchIndex.hasOwnProperty(crate)) {
1700                         continue;
1701                     }
1702                     crates.push(crate);
1703                 }
1704                 crates.sort();
1705                 for (var i = 0; i < crates.length; ++i) {
1706                     var klass = "crate";
1707                     if (rootPath !== "./" && crates[i] === window.currentCrate) {
1708                         klass += " current";
1709                     }
1710                     var link = document.createElement("a");
1711                     link.href = rootPath + crates[i] + "/index.html";
1712                     link.title = rawSearchIndex[crates[i]].doc;
1713                     link.className = klass;
1714                     link.textContent = crates[i];
1715
1716                     var li = document.createElement("li");
1717                     li.appendChild(link);
1718                     ul.appendChild(li);
1719                 }
1720                 sidebar.appendChild(div);
1721             }
1722         }
1723     }
1724
1725     window.initSearch = initSearch;
1726
1727     // delayed sidebar rendering.
1728     function initSidebarItems(items) {
1729         var sidebar = document.getElementsByClassName("sidebar-elems")[0];
1730         var current = window.sidebarCurrent;
1731
1732         function block(shortty, longty) {
1733             var filtered = items[shortty];
1734             if (!filtered) {
1735                 return;
1736             }
1737
1738             var div = document.createElement("div");
1739             div.className = "block " + shortty;
1740             var h3 = document.createElement("h3");
1741             h3.textContent = longty;
1742             div.appendChild(h3);
1743             var ul = document.createElement("ul");
1744
1745             var length = filtered.length;
1746             for (var i = 0; i < length; ++i) {
1747                 var item = filtered[i];
1748                 var name = item[0];
1749                 var desc = item[1]; // can be null
1750
1751                 var klass = shortty;
1752                 if (name === current.name && shortty === current.ty) {
1753                     klass += " current";
1754                 }
1755                 var path;
1756                 if (shortty === "mod") {
1757                     path = name + "/index.html";
1758                 } else {
1759                     path = shortty + "." + name + ".html";
1760                 }
1761                 var link = document.createElement("a");
1762                 link.href = current.relpath + path;
1763                 link.title = desc;
1764                 link.className = klass;
1765                 link.textContent = name;
1766                 var li = document.createElement("li");
1767                 li.appendChild(link);
1768                 ul.appendChild(li);
1769             }
1770             div.appendChild(ul);
1771             if (sidebar) {
1772                 sidebar.appendChild(div);
1773             }
1774         }
1775
1776         block("primitive", "Primitive Types");
1777         block("mod", "Modules");
1778         block("macro", "Macros");
1779         block("struct", "Structs");
1780         block("enum", "Enums");
1781         block("union", "Unions");
1782         block("constant", "Constants");
1783         block("static", "Statics");
1784         block("trait", "Traits");
1785         block("fn", "Functions");
1786         block("type", "Type Definitions");
1787         block("foreigntype", "Foreign Types");
1788         block("keyword", "Keywords");
1789     }
1790
1791     window.initSidebarItems = initSidebarItems;
1792
1793     window.register_implementors = function(imp) {
1794         var implementors = document.getElementById("implementors-list");
1795         var synthetic_implementors = document.getElementById("synthetic-implementors-list");
1796
1797         var libs = Object.getOwnPropertyNames(imp);
1798         var llength = libs.length;
1799         for (var i = 0; i < llength; ++i) {
1800             if (libs[i] === currentCrate) { continue; }
1801             var structs = imp[libs[i]];
1802
1803             var slength = structs.length;
1804             struct_loop:
1805             for (var j = 0; j < slength; ++j) {
1806                 var struct = structs[j];
1807
1808                 var list = struct.synthetic ? synthetic_implementors : implementors;
1809
1810                 if (struct.synthetic) {
1811                     var stlength = struct.types.length;
1812                     for (var k = 0; k < stlength; k++) {
1813                         if (window.inlined_types.has(struct.types[k])) {
1814                             continue struct_loop;
1815                         }
1816                         window.inlined_types.add(struct.types[k]);
1817                     }
1818                 }
1819
1820                 var code = document.createElement("code");
1821                 code.innerHTML = struct.text;
1822
1823                 var x = code.getElementsByTagName("a");
1824                 var xlength = x.length;
1825                 for (var it = 0; it < xlength; it++) {
1826                     var href = x[it].getAttribute("href");
1827                     if (href && href.indexOf("http") !== 0) {
1828                         x[it].setAttribute("href", rootPath + href);
1829                     }
1830                 }
1831                 var display = document.createElement("h3");
1832                 addClass(display, "impl");
1833                 display.innerHTML = "<span class=\"in-band\"><table class=\"table-display\">" +
1834                     "<tbody><tr><td><code>" + code.outerHTML + "</code></td><td></td></tr>" +
1835                     "</tbody></table></span>";
1836                 list.appendChild(display);
1837             }
1838         }
1839     };
1840     if (window.pending_implementors) {
1841         window.register_implementors(window.pending_implementors);
1842     }
1843
1844     function labelForToggleButton(sectionIsCollapsed) {
1845         if (sectionIsCollapsed) {
1846             // button will expand the section
1847             return "+";
1848         }
1849         // button will collapse the section
1850         // note that this text is also set in the HTML template in render.rs
1851         return "\u2212"; // "\u2212" is "−" minus sign
1852     }
1853
1854     function onEveryMatchingChild(elem, className, func) {
1855         if (elem && className && func) {
1856             var length = elem.childNodes.length;
1857             var nodes = elem.childNodes;
1858             for (var i = 0; i < length; ++i) {
1859                 if (hasClass(nodes[i], className)) {
1860                     func(nodes[i]);
1861                 } else {
1862                     onEveryMatchingChild(nodes[i], className, func);
1863                 }
1864             }
1865         }
1866     }
1867
1868     function toggleAllDocs(pageId, fromAutoCollapse) {
1869         var innerToggle = document.getElementById("toggle-all-docs");
1870         if (!innerToggle) {
1871             return;
1872         }
1873         if (hasClass(innerToggle, "will-expand")) {
1874             updateLocalStorage("rustdoc-collapse", "false");
1875             removeClass(innerToggle, "will-expand");
1876             onEveryMatchingChild(innerToggle, "inner", function(e) {
1877                 e.innerHTML = labelForToggleButton(false);
1878             });
1879             innerToggle.title = "collapse all docs";
1880             if (fromAutoCollapse !== true) {
1881                 onEachLazy(document.getElementsByClassName("collapse-toggle"), function(e) {
1882                     collapseDocs(e, "show");
1883                 });
1884             }
1885         } else {
1886             updateLocalStorage("rustdoc-collapse", "true");
1887             addClass(innerToggle, "will-expand");
1888             onEveryMatchingChild(innerToggle, "inner", function(e) {
1889                 var parent = e.parentNode;
1890                 var superParent = null;
1891
1892                 if (parent) {
1893                     superParent = parent.parentNode;
1894                 }
1895                 if (!parent || !superParent || superParent.id !== "main" ||
1896                     hasClass(parent, "impl") === false) {
1897                     e.innerHTML = labelForToggleButton(true);
1898                 }
1899             });
1900             innerToggle.title = "expand all docs";
1901             if (fromAutoCollapse !== true) {
1902                 onEachLazy(document.getElementsByClassName("collapse-toggle"), function(e) {
1903                     var parent = e.parentNode;
1904                     var superParent = null;
1905
1906                     if (parent) {
1907                         superParent = parent.parentNode;
1908                     }
1909                     if (!parent || !superParent || superParent.id !== "main" ||
1910                         hasClass(parent, "impl") === false) {
1911                         collapseDocs(e, "hide", pageId);
1912                     }
1913                 });
1914             }
1915         }
1916     }
1917
1918     function collapseDocs(toggle, mode, pageId) {
1919         if (!toggle || !toggle.parentNode) {
1920             return;
1921         }
1922
1923         function adjustToggle(arg) {
1924             return function(e) {
1925                 if (hasClass(e, "toggle-label")) {
1926                     if (arg) {
1927                         e.style.display = "inline-block";
1928                     } else {
1929                         e.style.display = "none";
1930                     }
1931                 }
1932                 if (hasClass(e, "inner")) {
1933                     e.innerHTML = labelForToggleButton(arg);
1934                 }
1935             };
1936         }
1937
1938         function implHider(addOrRemove, fullHide) {
1939             return function(n) {
1940                 var is_method = hasClass(n, "method") || fullHide;
1941                 if (is_method || hasClass(n, "type")) {
1942                     if (is_method === true) {
1943                         if (addOrRemove) {
1944                             addClass(n, "hidden-by-impl-hider");
1945                         } else {
1946                             removeClass(n, "hidden-by-impl-hider");
1947                         }
1948                     }
1949                     var ns = n.nextElementSibling;
1950                     while (true) {
1951                         if (ns && (
1952                                 hasClass(ns, "docblock") ||
1953                                 hasClass(ns, "stability"))) {
1954                             if (addOrRemove) {
1955                                 addClass(ns, "hidden-by-impl-hider");
1956                             } else {
1957                                 removeClass(ns, "hidden-by-impl-hider");
1958                             }
1959                             ns = ns.nextElementSibling;
1960                             continue;
1961                         }
1962                         break;
1963                     }
1964                 }
1965             };
1966         }
1967
1968         var relatedDoc;
1969         var action = mode;
1970         if (hasClass(toggle.parentNode, "impl") === false) {
1971             relatedDoc = toggle.parentNode.nextElementSibling;
1972             if (hasClass(relatedDoc, "stability")) {
1973                 relatedDoc = relatedDoc.nextElementSibling;
1974             }
1975             if (hasClass(relatedDoc, "docblock") || hasClass(relatedDoc, "sub-variant")) {
1976                 if (mode === "toggle") {
1977                     if (hasClass(relatedDoc, "hidden-by-usual-hider")) {
1978                         action = "show";
1979                     } else {
1980                         action = "hide";
1981                     }
1982                 }
1983                 if (action === "hide") {
1984                     addClass(relatedDoc, "hidden-by-usual-hider");
1985                     onEachLazy(toggle.childNodes, adjustToggle(true));
1986                     addClass(toggle.parentNode, "collapsed");
1987                 } else if (action === "show") {
1988                     removeClass(relatedDoc, "hidden-by-usual-hider");
1989                     removeClass(toggle.parentNode, "collapsed");
1990                     onEachLazy(toggle.childNodes, adjustToggle(false));
1991                 }
1992             }
1993         } else {
1994             // we are collapsing the impl block(s).
1995
1996             var parentElem = toggle.parentNode;
1997             relatedDoc = parentElem;
1998             var docblock = relatedDoc.nextElementSibling;
1999
2000             while (hasClass(relatedDoc, "impl-items") === false) {
2001                 relatedDoc = relatedDoc.nextElementSibling;
2002             }
2003
2004             if ((!relatedDoc && hasClass(docblock, "docblock") === false) ||
2005                 (pageId && document.getElementById(pageId))) {
2006                 return;
2007             }
2008
2009             // Hide all functions, but not associated types/consts.
2010
2011             if (mode === "toggle") {
2012                 if (hasClass(relatedDoc, "fns-now-collapsed") ||
2013                     hasClass(docblock, "hidden-by-impl-hider")) {
2014                     action = "show";
2015                 } else {
2016                     action = "hide";
2017                 }
2018             }
2019
2020             var dontApplyBlockRule = toggle.parentNode.parentNode.id !== "main";
2021             if (action === "show") {
2022                 removeClass(relatedDoc, "fns-now-collapsed");
2023                 removeClass(docblock, "hidden-by-usual-hider");
2024                 onEachLazy(toggle.childNodes, adjustToggle(false, dontApplyBlockRule));
2025                 onEachLazy(relatedDoc.childNodes, implHider(false, dontApplyBlockRule));
2026             } else if (action === "hide") {
2027                 addClass(relatedDoc, "fns-now-collapsed");
2028                 addClass(docblock, "hidden-by-usual-hider");
2029                 onEachLazy(toggle.childNodes, adjustToggle(true, dontApplyBlockRule);
2030                 onEachLazy(relatedDoc.childNodes, implHider(true, dontApplyBlockRule));
2031             }
2032         }
2033     }
2034
2035     function collapser(e, collapse) {
2036         // inherent impl ids are like "impl" or impl-<number>'.
2037         // they will never be hidden by default.
2038         var n = e.parentElement;
2039         if (n.id.match(/^impl(?:-\d+)?$/) === null) {
2040             // Automatically minimize all non-inherent impls
2041             if (collapse || hasClass(n, "impl")) {
2042                 collapseDocs(e, "hide", pageId);
2043             }
2044         }
2045     }
2046
2047     function autoCollapse(pageId, collapse) {
2048         if (collapse) {
2049             toggleAllDocs(pageId, true);
2050         } else if (getCurrentValue("rustdoc-trait-implementations") !== "false") {
2051             var impl_list = document.getElementById("implementations-list");
2052
2053             if (impl_list !== null) {
2054                 onEachLazy(impl_list.getElementsByClassName("collapse-toggle"), function(e) {
2055                     collapser(e, collapse);
2056                 });
2057             }
2058         }
2059     }
2060
2061     var toggles = document.getElementById("toggle-all-docs");
2062     if (toggles) {
2063         toggles.onclick = toggleAllDocs;
2064     }
2065
2066     function insertAfter(newNode, referenceNode) {
2067         referenceNode.parentNode.insertBefore(newNode, referenceNode.nextSibling);
2068     }
2069
2070     function createSimpleToggle(sectionIsCollapsed) {
2071         var toggle = document.createElement("a");
2072         toggle.href = "javascript:void(0)";
2073         toggle.className = "collapse-toggle";
2074         toggle.innerHTML = "[<span class=\"inner\">" + labelForToggleButton(sectionIsCollapsed) +
2075                            "</span>]";
2076         return toggle;
2077     }
2078
2079     var toggle = createSimpleToggle(false);
2080
2081     var func = function(e) {
2082         var next = e.nextElementSibling;
2083         if (!next) {
2084             return;
2085         }
2086         if (hasClass(next, "docblock") ||
2087             (hasClass(next, "stability") &&
2088              hasClass(next.nextElementSibling, "docblock"))) {
2089             insertAfter(toggle.cloneNode(true), e.childNodes[e.childNodes.length - 1]);
2090         }
2091     };
2092
2093     var funcImpl = function(e) {
2094         var next = e.nextElementSibling;
2095         if (next && hasClass(next, "docblock")) {
2096             next = next.nextElementSibling;
2097         }
2098         if (!next) {
2099             return;
2100         }
2101         if (next.getElementsByClassName("method").length > 0 && hasClass(e, "impl")) {
2102             insertAfter(toggle.cloneNode(true), e.childNodes[e.childNodes.length - 1]);
2103         }
2104     };
2105
2106     onEachLazy(document.getElementsByClassName("method"), func);
2107     onEachLazy(document.getElementsByClassName("associatedconstant"), func);
2108     onEachLazy(document.getElementsByClassName("impl"), funcImpl);
2109     var impl_call = function() {};
2110     if (getCurrentValue("rustdoc-method-docs") !== "false") {
2111         impl_call = function(e, newToggle, pageId) {
2112             if (e.id.match(/^impl(?:-\d+)?$/) === null) {
2113                 // Automatically minimize all non-inherent impls
2114                 if (hasClass(e, "impl")) {
2115                     collapseDocs(newToggle, "hide", pageId);
2116                 }
2117             }
2118         };
2119     }
2120     var pageId = getPageId();
2121     var newToggle = document.createElement("a");
2122     newToggle.href = "javascript:void(0)";
2123     newToggle.className = "collapse-toggle hidden-default collapsed";
2124     newToggle.innerHTML = "[<span class=\"inner\">" + labelForToggleButton(true) +
2125                           "</span>] Show hidden undocumented items";
2126     function toggleClicked() {
2127         if (hasClass(this, "collapsed")) {
2128             removeClass(this, "collapsed");
2129             onEachLazy(this.parentNode.getElementsByClassName("hidden"), function(x) {
2130                 if (hasClass(x, "content") === false) {
2131                     removeClass(x, "hidden");
2132                     addClass(x, "x");
2133                 }
2134             }, true);
2135             this.innerHTML = "[<span class=\"inner\">" + labelForToggleButton(false) +
2136                              "</span>] Hide undocumented items";
2137         } else {
2138             addClass(this, "collapsed");
2139             onEachLazy(this.parentNode.getElementsByClassName("x"), function(x) {
2140                 if (hasClass(x, "content") === false) {
2141                     addClass(x, "hidden");
2142                     removeClass(x, "x");
2143                 }
2144             }, true);
2145             this.innerHTML = "[<span class=\"inner\">" + labelForToggleButton(true) +
2146                              "</span>] Show hidden undocumented items";
2147         }
2148     }
2149     onEachLazy(document.getElementsByClassName("impl-items"), function(e) {
2150         onEachLazy(e.getElementsByClassName("associatedconstant"), func);
2151         var hiddenElems = e.getElementsByClassName("hidden");
2152         var needToggle = false;
2153
2154         var hlength = hiddenElems.length;
2155         for (var i = 0; i < hlength; ++i) {
2156             if (hasClass(hiddenElems[i], "content") === false &&
2157                 hasClass(hiddenElems[i], "docblock") === false) {
2158                 needToggle = true;
2159                 break;
2160             }
2161         }
2162         if (needToggle === true) {
2163             var inner_toggle = newToggle.cloneNode(true);
2164             inner_toggle.onclick = toggleClicked;
2165             e.insertBefore(inner_toggle, e.firstChild);
2166             impl_call(e, inner_toggle, pageId);
2167         }
2168     });
2169
2170     function createToggle(otherMessage, fontSize, extraClass, show) {
2171         var span = document.createElement("span");
2172         span.className = "toggle-label";
2173         if (show) {
2174             span.style.display = "none";
2175         }
2176         if (!otherMessage) {
2177             span.innerHTML = "&nbsp;Expand&nbsp;description";
2178         } else {
2179             span.innerHTML = otherMessage;
2180         }
2181
2182         if (fontSize) {
2183             span.style.fontSize = fontSize;
2184         }
2185
2186         var mainToggle = toggle.cloneNode(true);
2187         mainToggle.appendChild(span);
2188
2189         var wrapper = document.createElement("div");
2190         wrapper.className = "toggle-wrapper";
2191         if (!show) {
2192             addClass(wrapper, "collapsed");
2193             var inner = mainToggle.getElementsByClassName("inner");
2194             if (inner && inner.length > 0) {
2195                 inner[0].innerHTML = "+";
2196             }
2197         }
2198         if (extraClass) {
2199             addClass(wrapper, extraClass);
2200         }
2201         wrapper.appendChild(mainToggle);
2202         return wrapper;
2203     }
2204
2205     var showItemDeclarations = getCurrentValue("rustdoc-item-declarations") === "false";
2206     function buildToggleWrapper(e) {
2207         if (hasClass(e, "autohide")) {
2208             var wrap = e.previousElementSibling;
2209             if (wrap && hasClass(wrap, "toggle-wrapper")) {
2210                 var inner_toggle = wrap.childNodes[0];
2211                 var extra = e.childNodes[0].tagName === "H3";
2212
2213                 e.style.display = "none";
2214                 addClass(wrap, "collapsed");
2215                 onEachLazy(inner_toggle.getElementsByClassName("inner"), function(e) {
2216                     e.innerHTML = labelForToggleButton(true);
2217                 });
2218                 onEachLazy(inner_toggle.getElementsByClassName("toggle-label"), function(e) {
2219                     e.style.display = "inline-block";
2220                     if (extra === true) {
2221                         i_e.innerHTML = " Show " + e.childNodes[0].innerHTML;
2222                     }
2223                 });
2224             }
2225         }
2226         if (e.parentNode.id === "main") {
2227             var otherMessage = "";
2228             var fontSize;
2229             var extraClass;
2230
2231             if (hasClass(e, "type-decl")) {
2232                 fontSize = "20px";
2233                 otherMessage = "&nbsp;Show&nbsp;declaration";
2234                 if (showItemDeclarations === false) {
2235                     extraClass = "collapsed";
2236                 }
2237             } else if (hasClass(e, "sub-variant")) {
2238                 otherMessage = "&nbsp;Show&nbsp;fields";
2239             } else if (hasClass(e, "non-exhaustive")) {
2240                 otherMessage = "&nbsp;This&nbsp;";
2241                 if (hasClass(e, "non-exhaustive-struct")) {
2242                     otherMessage += "struct";
2243                 } else if (hasClass(e, "non-exhaustive-enum")) {
2244                     otherMessage += "enum";
2245                 } else if (hasClass(e, "non-exhaustive-type")) {
2246                     otherMessage += "type";
2247                 }
2248                 otherMessage += "&nbsp;is&nbsp;marked&nbsp;as&nbsp;non-exhaustive";
2249             } else if (hasClass(e.childNodes[0], "impl-items")) {
2250                 extraClass = "marg-left";
2251             }
2252
2253             e.parentNode.insertBefore(
2254                 createToggle(otherMessage,
2255                              fontSize,
2256                              extraClass,
2257                              hasClass(e, "type-decl") === false || showItemDeclarations === true),
2258                 e);
2259             if (hasClass(e, "type-decl") === true && showItemDeclarations === true) {
2260                 collapseDocs(e.previousSibling.childNodes[0], "toggle");
2261             }
2262         }
2263     }
2264
2265     onEachLazy(document.getElementsByClassName("docblock"), buildToggleWrapper);
2266     onEachLazy(document.getElementsByClassName("sub-variant"), buildToggleWrapper);
2267
2268     // In the search display, allows to switch between tabs.
2269     function printTab(nb) {
2270         if (nb === 0 || nb === 1 || nb === 2) {
2271             currentTab = nb;
2272         }
2273         var nb_copy = nb;
2274         onEachLazy(document.getElementById("titles").childNodes, function(elem) {
2275             if (nb_copy === 0) {
2276                 addClass(elem, "selected");
2277             } else {
2278                 removeClass(elem, "selected");
2279             }
2280             nb_copy -= 1;
2281         });
2282         onEachLazy(document.getElementById("results").childNodes, function(elem) {
2283             if (nb === 0) {
2284                 elem.style.display = "";
2285             } else {
2286                 elem.style.display = "none";
2287             }
2288             nb -= 1;
2289         });
2290     }
2291
2292     function createToggleWrapper(tog) {
2293         var span = document.createElement("span");
2294         span.className = "toggle-label";
2295         span.style.display = "none";
2296         span.innerHTML = "&nbsp;Expand&nbsp;attributes";
2297         tog.appendChild(span);
2298
2299         var wrapper = document.createElement("div");
2300         wrapper.className = "toggle-wrapper toggle-attributes";
2301         wrapper.appendChild(tog);
2302         return wrapper;
2303     }
2304
2305     // To avoid checking on "rustdoc-item-attributes" value on every loop...
2306     var itemAttributesFunc = function() {};
2307     if (getCurrentValue("rustdoc-item-attributes") !== "false") {
2308         itemAttributesFunc = function(x) {
2309             collapseDocs(x.previousSibling.childNodes[0], "toggle");
2310         };
2311     }
2312     var attributesToggle = createToggleWrapper(createSimpleToggle(false));
2313     onEachLazy(main.getElementsByClassName("attributes"), function(i_e) {
2314         i_e.parentNode.insertBefore(attributesToggle.cloneNode(true), i_e);
2315         itemAttributesFunc(i_e);
2316     });
2317
2318     // To avoid checking on "rustdoc-line-numbers" value on every loop...
2319     var lineNumbersFunc = function() {};
2320     if (getCurrentValue("rustdoc-line-numbers") === "true") {
2321         lineNumbersFunc = function(x) {
2322             var count = x.textContent.split("\n").length;
2323             var elems = [];
2324             for (var i = 0; i < count; ++i) {
2325                 elems.push(i + 1);
2326             }
2327             var node = document.createElement("pre");
2328             addClass(node, "line-number");
2329             node.innerHTML = elems.join("\n");
2330             x.parentNode.insertBefore(node, x);
2331         };
2332     }
2333     onEachLazy(document.getElementsByClassName("rust-example-rendered"), function(e) {
2334         if (hasClass(e, "compile_fail")) {
2335             e.addEventListener("mouseover", function(event) {
2336                 this.parentElement.previousElementSibling.childNodes[0].style.color = "#f00";
2337             });
2338             e.addEventListener("mouseout", function(event) {
2339                 this.parentElement.previousElementSibling.childNodes[0].style.color = "";
2340             });
2341         } else if (hasClass(e, "ignore")) {
2342             e.addEventListener("mouseover", function(event) {
2343                 this.parentElement.previousElementSibling.childNodes[0].style.color = "#ff9200";
2344             });
2345             e.addEventListener("mouseout", function(event) {
2346                 this.parentElement.previousElementSibling.childNodes[0].style.color = "";
2347             });
2348         }
2349         lineNumbersFunc(e);
2350     });
2351
2352     function showModal(content) {
2353         var modal = document.createElement("div");
2354         modal.id = "important";
2355         addClass(modal, "modal");
2356         modal.innerHTML = "<div class=\"modal-content\"><div class=\"close\" id=\"modal-close\">✕" +
2357                           "</div><div class=\"whiter\"></div><span class=\"docblock\">" + content +
2358                           "</span></div>";
2359         document.getElementsByTagName("body")[0].appendChild(modal);
2360         document.getElementById("modal-close").onclick = hideModal;
2361         modal.onclick = hideModal;
2362     }
2363
2364     function hideModal() {
2365         var modal = document.getElementById("important");
2366         if (modal) {
2367             modal.parentNode.removeChild(modal);
2368         }
2369     }
2370
2371     onEachLazy(document.getElementsByClassName("important-traits"), function(e) {
2372         e.onclick = function() {
2373             showModal(e.lastElementChild.innerHTML);
2374         };
2375     });
2376
2377     function putBackSearch(search_input) {
2378         if (search_input.value !== "") {
2379             addClass(main, "hidden");
2380             removeClass(document.getElementById("search"), "hidden");
2381             if (browserSupportsHistoryApi()) {
2382                 history.replaceState(search_input.value,
2383                                      "",
2384                                      "?search=" + encodeURIComponent(search_input.value));
2385             }
2386         }
2387     }
2388
2389     if (search_input) {
2390         search_input.onfocus = function() {
2391             putBackSearch(this);
2392         };
2393     }
2394
2395     var params = getQueryStringParams();
2396     if (params && params.search) {
2397         addClass(main, "hidden");
2398         var search = document.getElementById("search");
2399         removeClass(search, "hidden");
2400         search.innerHTML = "<h3 style=\"text-align: center;\">Loading search results...</h3>";
2401     }
2402
2403     var sidebar_menu = document.getElementsByClassName("sidebar-menu")[0];
2404     if (sidebar_menu) {
2405         sidebar_menu.onclick = function() {
2406             var sidebar = document.getElementsByClassName("sidebar")[0];
2407             if (hasClass(sidebar, "mobile") === true) {
2408                 hideSidebar();
2409             } else {
2410                 showSidebar();
2411             }
2412         };
2413     }
2414
2415     window.onresize = function() {
2416         hideSidebar();
2417     };
2418
2419     autoCollapse(getPageId(), getCurrentValue("rustdoc-collapse") === "true");
2420
2421     if (window.location.hash && window.location.hash.length > 0) {
2422         expandSection(window.location.hash.replace(/^#/, ""));
2423     }
2424
2425     if (main) {
2426         onEachLazy(main.getElementsByClassName("loading-content"), function(e) {
2427             e.remove();
2428         });
2429         onEachLazy(main.childNodes, function(e) {
2430             // Unhide the actual content once loading is complete. Headers get
2431             // flex treatment for their horizontal layout, divs get block treatment
2432             // for vertical layout (column-oriented flex layout for divs caused
2433             // errors in mobile browsers).
2434             if (e.tagName === "H2" || e.tagName === "H3") {
2435                 let nextTagName = e.nextElementSibling.tagName;
2436                 if (nextTagName == "H2" || nextTagName == "H3") {
2437                     e.nextElementSibling.style.display = "flex";
2438                 } else {
2439                     e.nextElementSibling.style.display = "block";
2440                 }
2441             }
2442         });
2443     }
2444
2445     function addSearchOptions(crates) {
2446         var elem = document.getElementById('crate-search');
2447
2448         if (!elem) {
2449             return;
2450         }
2451         var crates_text = [];
2452         if (Object.keys(crates).length > 1) {
2453             for (var crate in crates) {
2454                 if (crates.hasOwnProperty(crate)) {
2455                     crates_text.push(crate);
2456                 }
2457             }
2458         }
2459         crates_text.sort(function(a, b) {
2460             var lower_a = a.toLowerCase();
2461             var lower_b = b.toLowerCase();
2462
2463             if (lower_a < lower_b) {
2464                 return -1;
2465             } else if (lower_a > lower_b) {
2466                 return 1;
2467             }
2468             return 0;
2469         });
2470         for (var i = 0; i < crates_text.length; ++i) {
2471             var option = document.createElement("option");
2472             option.value = crates_text[i];
2473             option.innerText = crates_text[i];
2474             elem.appendChild(option);
2475         }
2476     }
2477
2478     window.addSearchOptions = addSearchOptions;
2479 }());
2480
2481 // Sets the focus on the search bar at the top of the page
2482 function focusSearchBar() {
2483     document.getElementsByClassName("search-input")[0].focus();
2484 }
2485
2486 // Removes the focus from the search bar
2487 function defocusSearchBar() {
2488     document.getElementsByClassName("search-input")[0].blur();
2489 }