diff --git a/Cargo.lock b/Cargo.lock index 4676e4127e83c..4d73e51816e0d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3910,6 +3910,7 @@ dependencies = [ name = "rustc_macros" version = "0.1.0" dependencies = [ + "phf_codegen", "proc-macro2", "quote", "syn", @@ -4197,6 +4198,7 @@ version = "0.0.0" dependencies = [ "cfg-if 0.1.10", "md-5", + "phf", "rustc_arena", "rustc_data_structures", "rustc_index", diff --git a/compiler/rustc_macros/Cargo.toml b/compiler/rustc_macros/Cargo.toml index 73eb0dd56d772..f3d1a171946a0 100644 --- a/compiler/rustc_macros/Cargo.toml +++ b/compiler/rustc_macros/Cargo.toml @@ -10,5 +10,6 @@ proc-macro = true [dependencies] synstructure = "0.12.1" syn = { version = "1", features = ["full"] } +phf_codegen = "0.8" proc-macro2 = "1" quote = "1" diff --git a/compiler/rustc_macros/src/symbols.rs b/compiler/rustc_macros/src/symbols.rs index 5b932864dff5d..4138cabd8f70c 100644 --- a/compiler/rustc_macros/src/symbols.rs +++ b/compiler/rustc_macros/src/symbols.rs @@ -28,8 +28,8 @@ use std::collections::HashMap; use syn::parse::{Parse, ParseStream, Result}; use syn::{braced, punctuated::Punctuated, Ident, LitStr, Token}; -#[cfg(test)] -mod tests; +// #[cfg(test)] +// mod tests; mod kw { syn::custom_keyword!(Keywords); @@ -127,6 +127,7 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { let mut keyword_stream = quote! {}; let mut symbols_stream = quote! {}; let mut prefill_stream = quote! {}; + let mut symbol_strings = Vec::new(); let mut counter = 0u32; let mut keys = HashMap::::with_capacity(input.keywords.len() + input.symbols.len() + 10); @@ -163,6 +164,7 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { keyword_stream.extend(quote! { pub const #name: Symbol = Symbol::new(#counter); }); + symbol_strings.push(value_string); counter += 1; } @@ -182,6 +184,7 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { symbols_stream.extend(quote! { pub const #name: Symbol = Symbol::new(#counter); }); + symbol_strings.push(value); counter += 1; } @@ -194,9 +197,19 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { prefill_stream.extend(quote! { #n, }); + symbol_strings.push(n); } let _ = counter; // for future use + // Build the PHF map. This translates from strings to Symbol values. + let mut phf_map = phf_codegen::Map::<&str>::new(); + for (symbol_index, symbol) in symbol_strings.iter().enumerate() { + phf_map.entry(symbol, format!("Symbol::new({})", symbol_index as u32).as_str()); + } + let phf_map_built = phf_map.build(); + let phf_map_text = phf_map_built.to_string(); + let phf_map_expr = syn::parse_str::(&phf_map_text).unwrap(); + let output = quote! { const SYMBOL_DIGITS_BASE: u32 = #digits_base; @@ -222,6 +235,8 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec) { ]) } } + + static STATIC_SYMBOLS_PHF: ::phf::Map<&'static str, Symbol> = #phf_map_expr; }; (output, errors.list) diff --git a/compiler/rustc_span/Cargo.toml b/compiler/rustc_span/Cargo.toml index 08645990c4870..90b3c10f804dc 100644 --- a/compiler/rustc_span/Cargo.toml +++ b/compiler/rustc_span/Cargo.toml @@ -20,3 +20,4 @@ tracing = "0.1" sha-1 = "0.9" sha2 = "0.9" md-5 = "0.9" +phf = "0.8" diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs index 99f01062545a7..4cc9d8fe93bd6 100644 --- a/compiler/rustc_span/src/lib.rs +++ b/compiler/rustc_span/src/lib.rs @@ -18,10 +18,12 @@ #![feature(crate_visibility_modifier)] #![feature(const_fn)] #![feature(const_panic)] +#![feature(hash_raw_entry)] #![feature(negative_impls)] #![feature(nll)] #![feature(min_specialization)] #![feature(option_expect_none)] +#![feature(zzz)] #[macro_use] extern crate rustc_macros; diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index 64b50a9b70a70..83006c602d72d 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -1,9 +1,11 @@ +// ignore-tidy-filelength + //! An "interner" is a data structure that associates values with usize tags and //! allows bidirectional lookup; i.e., given a value, one can easily find the //! type, and vice versa. use rustc_arena::DroplessArena; -use rustc_data_structures::fx::FxHashMap; +use rustc_data_structures::fx::{FxHashMap, FxHasher}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey}; use rustc_macros::HashStable_Generic; use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; @@ -1254,6 +1256,3609 @@ symbols! { xmm_reg, ymm_reg, zmm_reg, + zz0000: "'tcx", + zz0001: "'a", + zz0002: " ```", + zz0003: "tcx", + zz0004: "T", + zz0005: "this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead?", + zz0006: "1.0.0", + zz0007: "rust1", + zz0008: "STRUCT", + zz0009: "a", + zz0010: "__encoder", + zz0011: " # Examples", + zz0012: "", + zz0013: "", + zz0014: "", + zz0015: "'hir", + zz0016: "__err", + zz0017: " }", + zz0018: "A", + zz0019: "span", + zz0020: "RustaceansAreAwesome", + zz0021: "__self_0", + zz0022: "'data", + zz0023: "b", + zz0024: "F", + zz0025: " ", + zz0026: "Symbol", + zz0027: "I", + zz0028: "__res", + zz0029: "V", + zz0030: "__decoder", + zz0031: "K", + zz0032: "'b", + zz0033: "arg0", + zz0034: "data", + zz0035: "B", + zz0036: "hir", + zz0037: "$crate::valueset", + zz0038: "r", + zz0039: "inner", + zz0040: "'r", + zz0041: "rustc_hir", + zz0042: "rustc_span", + zz0043: "len", + zz0044: "new_v1", + zz0045: "__binding_0", + zz0046: "k", + zz0047: "'file", + zz0048: "$crate::fieldset", + zz0049: "forward_ref_binop", + zz0050: "E", + zz0051: "value", + zz0052: "D", + zz0053: "rustc_middle", + zz0054: "target", + zz0055: "rustc_data_structures", + zz0056: "Display", + zz0057: "ptr", + zz0058: "tracing", + zz0059: "rustc_ast", + zz0060: "__self_0_0", + zz0061: "R", + zz0062: "S", + zz0063: "e", + zz0064: "rustc_index", + zz0065: "HashStable", + zz0066: "$crate::event", + zz0067: "parent", + zz0068: "v", + zz0069: "'s", + zz0070: "'v", + zz0071: "cfg_if", + zz0072: "'__ctx", + zz0073: "Span", + zz0074: "s", + zz0075: "Item", + zz0076: "Ret", + zz0077: "def_id", + zz0078: " }", + zz0079: "arg1", + zz0080: "id", + zz0081: "N", + zz0082: "hash_stable", + zz0083: "key", + zz0084: "x", + zz0085: "P", + zz0086: "cx", + zz0087: "Cache", + zz0088: "compute", + zz0089: "U", + zz0090: "c", + zz0091: "hash_result", + zz0092: "$crate::format_args", + zz0093: " Basic usage:", + zz0094: "handle_cycle_error", + zz0095: "query_state", + zz0096: "DEP_KIND", + zz0097: "ANON", + zz0098: "EVAL_ALWAYS", + zz0099: "derive_clone_copy", + zz0100: "__binding_1", + zz0101: "mem", + zz0102: "G", + zz0103: "H", + zz0104: "__arg_1_0", + zz0105: "TypeFoldable", + zz0106: "rustc_std_workspace_core", + zz0107: "attempt to divide by zero", + zz0108: "__hcx", + zz0109: "__hasher", + zz0110: "end", + zz0111: "step_trait_ext", + zz0112: "arg", + zz0113: "step_trait", + zz0114: "Value", + zz0115: "avx512f", + zz0116: "sess", + zz0117: "__self_0_1", + zz0118: "core_panic", + zz0119: "ast", + zz0120: "__self_1_0", + zz0121: "t", + zz0122: "fold", + zz0123: "Type", + zz0124: " documentation for more.", + zz0125: "p", + zz0126: "n", + zz0127: "rustc_errors", + zz0128: "$crate::level_enabled", + zz0129: "$crate::callsite", + zz0130: "$crate::__export::format_args", + zz0131: "DefId", + zz0132: " # Safety", + zz0133: "$crate::newtype_index", + zz0134: "hashbrown", + zz0135: " ```rust", + zz0136: " # Example", + zz0137: "__E", + zz0138: "src", + zz0139: "1.27.0", + zz0140: "1.", + zz0141: "fields", + zz0142: "count", + zz0143: "TyDecodable", + zz0144: "write", + zz0145: "event", + zz0146: "__ctx", + zz0147: "ENUM", + zz0148: "rustc_session", + zz0149: "$crate::quote_token_with_context", + zz0150: "attrs", + zz0151: "HashStable_Generic", + zz0152: "__self_vi", + zz0153: "layout", + zz0154: "hir_id", + zz0155: "non_upper_case_globals", + zz0156: "Const", + zz0157: "Path", + zz0158: "body", + zz0159: "rustc_target", + zz0160: "__self_1", + zz0161: "base", + zz0162: "token", + zz0163: "1.28.0", + zz0164: "$crate::__tracing_stringify", + zz0165: "shl_impl", + zz0166: "rustc_std_workspace_alloc", + zz0167: "object", + zz0168: "simd_test", + zz0169: "$crate::metadata", + zz0170: "$crate::identify_callsite", + zz0171: "12", + zz0172: "$crate::__tracing_log", + zz0173: "doc_comment", + zz0174: "TyEncodable", + zz0175: "Level", + zz0176: "elem", + zz0177: "args", + zz0178: " See its documentation for more.", + zz0179: "gimli", + zz0180: "emr", + zz0181: "assert_instr", + zz0182: "rustc_demangle", + zz0183: "Q", + zz0184: "addr2line", + zz0185: "declare_lint", + zz0186: "simd_ty", + zz0187: "msg", + zz0188: "1.34.0", + zz0189: "visitor", + zz0190: "get", + zz0191: "__CTX", + zz0192: "1.32.0", + zz0193: "stable_hasher", + zz0194: "UNION", + zz0195: "Fn", + zz0196: "substs", + zz0197: "String", + zz0198: "push", + zz0199: "IntoIter", + zz0200: "Flags", + zz0201: "0b1111111111111111", + zz0202: " ```no_run", + zz0203: "10", + zz0204: "mir", + zz0205: "MAX", + zz0206: "Ident", + zz0207: "lvl", + zz0208: " # }", + zz0209: "Expr", + zz0210: "none", + zz0211: "buf", + zz0212: "StableHasher", + zz0213: "Deref", + zz0214: "Box", + zz0215: "error", + zz0216: "const_caller_location", + zz0217: "to_string", + zz0218: "$crate::panic", + zz0219: "imm8", + zz0220: " unsafe {", + zz0221: "is_empty", + zz0222: "__arg_1_vi", + zz0223: "callsite", + zz0224: "smallvec", + zz0225: "size_hint", + zz0226: "cmd", + zz0227: "Less", + zz0228: "__folder", + zz0229: "rustfmt::skip", + zz0230: "11", + zz0231: "__m512i", + zz0232: "13", + zz0233: "AssertParamIsClone", + zz0234: "Iter", + zz0235: "__binding_2", + zz0236: "14", + zz0237: " # Panics", + zz0238: "simd_x86", + zz0239: "PhantomData", + zz0240: "15", + zz0241: "sse2", + zz0242: "__self", + zz0243: "io", + zz0244: "T11", + zz0245: "walk_list", + zz0246: "Node", + zz0247: "Greater", + zz0248: "bitflags", + zz0249: "expand", + zz0250: "Cow", + zz0251: "idx", + zz0252: "param_env", + zz0253: "__self_0_2", + zz0254: "1.2.0", + zz0255: "Idx", + zz0256: "ExprKind", + zz0257: "J", + zz0258: "this", + zz0259: "__variant_idx", + zz0260: "T10", + zz0261: "StableHashingContext", + zz0262: "1.26.0", + zz0263: "length", + zz0264: "node", + zz0265: "cmdsize", + zz0266: "Ref", + zz0267: "warnings", + zz0268: "place", + zz0269: "unused_lifetimes", + zz0270: "non_camel_case_types", + zz0271: "rust_2018_idioms", + zz0272: "insert", + zz0273: "1.36.0", + zz0274: "generics", + zz0275: "16", + zz0276: "assert_eq", + zz0277: "Size", + zz0278: "rest", + zz0279: "bx", + zz0280: "0.", + zz0281: "Index", + zz0282: "borrow", + zz0283: "bytes", + zz0284: "Lifetime", + zz0285: "rustc_infer", + zz0286: "sp", + zz0287: "dst", + zz0288: "MIN", + zz0289: "Closure", + zz0290: "pos", + zz0291: " };", + zz0292: "hasher", + zz0293: " });", + zz0294: " );", + zz0295: "dw", + zz0296: "Reserved", + zz0297: "Local", + zz0298: "T9", + zz0299: "predicate", + zz0300: "CTX", + zz0301: "u", + zz0302: "bits", + zz0303: "Field", + zz0304: "chalk_ir", + zz0305: "__self_1_1", + zz0306: "ItemKind", + zz0307: "forward_ref_op_assign", + zz0308: " use std::collections::HashMap;", + zz0309: "infcx", + zz0310: "query", + zz0311: "rustc_macros", + zz0312: "'de", + zz0313: "`", + zz0314: "::std::format_args", + zz0315: "Int", + zz0316: "32", + zz0317: "op", + zz0318: "into", + zz0319: "__F", + zz0320: "rustc_trait_selection", + zz0321: "1.7.0", + zz0322: "__m128i", + zz0323: "0xFFFFFF00", + zz0324: "1.9.0", + zz0325: "left_val", + zz0326: "right_val", + zz0327: "def", + zz0328: "Acc", + zz0329: "Array", + zz0330: "Struct", + zz0331: "max", + zz0332: " [slices]: ../../std/primitive.slice.html", + zz0333: "location", + zz0334: "Trait", + zz0335: "as_ref", + zz0336: "1.20.0", + zz0337: "arg2", + zz0338: "tail", + zz0339: "res", + zz0340: "IndexVec", + zz0341: "Key", + zz0342: " use std::thread;", + zz0343: "2.", + zz0344: "iterators are lazy and do nothing unless consumed", + zz0345: "T8", + zz0346: "ich", + zz0347: "int_module", + zz0348: "init", + zz0349: "1.17.0", + zz0350: "Sized", + zz0351: "CALLSITE", + zz0352: " let a = [1, 2, 3];", + zz0353: "metadata", + zz0354: "winapi", + zz0355: "64", + zz0356: "$crate::quote_token", + zz0357: "Slice", + zz0358: "GenericArg", + zz0359: "Offset", + zz0360: "matches", + zz0361: "_marker", + zz0362: "$crate::declare_lint", + zz0363: "W", + zz0364: "tokens", + zz0365: "Region", + zz0366: "collect", + zz0367: "HirId", + zz0368: "Static", + zz0369: "1.4.0", + zz0370: "param", + zz0371: "bug", + zz0372: "describe", + zz0373: "last", + zz0374: "Block", + zz0375: "Mutability", + zz0376: "sig", + zz0377: "source", + zz0378: "L", + zz0379: "rustc::internal", + zz0380: "'ll", + zz0381: "PathBuf", + zz0382: "AssertParamIsEq", + zz0383: "Generator", + zz0384: "section", + zz0385: "y", + zz0386: "contains", + zz0387: "head", + zz0388: "State", + zz0389: "trait_ref", + zz0390: "Empty", + zz0391: "'i", + zz0392: "avx512bw", + zz0393: "__m256i", + zz0394: "symbol", + zz0395: "capacity", + zz0396: "ControlFlow", + zz0397: "bounds", + zz0398: "1.6.0", + zz0399: "FnMut", + zz0400: " use std::ptr;", + zz0401: "codec", + zz0402: " use std::fmt;", + zz0403: "lock", + zz0404: "Write", + zz0405: "DUMMY_SP", + zz0406: "DerefMut", + zz0407: "level", + zz0408: " `](", + zz0409: "input", + zz0410: "struct_span_err", + zz0411: "T7", + zz0412: "obligation", + zz0413: "Bound", + zz0414: "Float", + zz0415: "entry", + zz0416: "Lrc", + zz0417: "FusedIterator", + zz0418: "CrateNum", + zz0419: "Scalar", + zz0420: "1.8.0", + zz0421: " [`HashMap`]: struct.HashMap.html", + zz0422: "1.10.0", + zz0423: "lazy_static", + zz0424: "table", + zz0425: "Borrow", + zz0426: "'unit", + zz0427: "__self_0_3", + zz0428: "'abbrev", + zz0429: "Location", + zz0430: "header", + zz0431: "rustc_codegen_ssa", + zz0432: "__m128", + zz0433: "PatKind", + zz0434: "Body", + zz0435: "SubstsRef", + zz0436: "__self_2", + zz0437: "__arg_1_1", + zz0438: "Rhs", + zz0439: "zero", + zz0440: "DEBUG", + zz0441: "FromIterator", + zz0442: "__arg_1", + zz0443: "get_mut", + zz0444: "Global", + zz0445: " Ok(())", + zz0446: "items", + zz0447: "Lift", + zz0448: "emit", + zz0449: "BinOp", + zz0450: " use std::mem;", + zz0451: "1.5.0", + zz0452: "log", + zz0453: "debug_builders", + zz0454: "traits", + zz0455: " ```text", + zz0456: "Tag", + zz0457: "private", + zz0458: "register", + zz0459: "LocalDefId", + zz0460: "lo", + zz0461: " The stabilized version of this intrinsic is available on the", + zz0462: "set", + zz0463: "Tuple", + zz0464: "Mask", + zz0465: "T6", + zz0466: " [`Iterator`]: trait.Iterator.html", + zz0467: "__m128d", + zz0468: " let mut map = HashMap::new();", + zz0469: "Pat", + zz0470: "interner", + zz0471: "source_map", + zz0472: "IterMut", + zz0473: "HashStableContext", + zz0474: "Header", + zz0475: "Place", + zz0476: "kw", + zz0477: "Union", + zz0478: "'cx", + zz0479: "left", + zz0480: "fold_with", + zz0481: "DefKind", + zz0482: "right", + zz0483: "source_info", + zz0484: "Add", + zz0485: "1.40.0", + zz0486: "FnOnce", + zz0487: "m", + zz0488: " use hashbrown::HashMap;", + zz0489: "queries", + zz0490: "Metadata", + zz0491: " ```rust,no_run", + zz0492: "Drain", + zz0493: "Id", + zz0494: "MacCall", + zz0495: "TerminatorKind", + zz0496: "drain", + zz0497: "MaybeUninit", + zz0498: "ll", + zz0499: "BasicBlock", + zz0500: "AllocError", + zz0501: "visit_with", + zz0502: "O", + zz0503: "Adt", + zz0504: "extend", + zz0505: "llvm", + zz0506: "DEFINE_GUID", + zz0507: "SmallVec", + zz0508: "3.", + zz0509: "1.38.0", + zz0510: "valueset", + zz0511: "rclBounds", + zz0512: " assert_eq!(iter.next(), None);", + zz0513: "Attribute", + zz0514: " }", + zz0515: "Lit", + zz0516: "__binding_3", + zz0517: "Break", + zz0518: "M", + zz0519: "unused_variables", + zz0520: "process", + zz0521: "span_label", + zz0522: "super_fold_with", + zz0523: "assert_eq_m512i", + zz0524: "BitFlags", + zz0525: " use std::mem::MaybeUninit;", + zz0526: "Pointer", + zz0527: "NonNull", + zz0528: "opts", + zz0529: "cause", + zz0530: "self_ty", + zz0531: "super_visit_with", + zz0532: "did", + zz0533: " # fn main() {", + zz0534: "BorrowType", + zz0535: "TyAlias", + zz0536: "dep_node_index", + zz0537: "nth", + zz0538: "begin", + zz0539: "1.13.0", + zz0540: "ErrorReported", + zz0541: "stack", + zz0542: "'ast", + zz0543: "1.3.0", + zz0544: "range", + zz0545: "1.1.0", + zz0546: "1.16.0", + zz0547: "output", + zz0548: " assert_eq!(", + zz0549: "Applicability", + zz0550: "debug_assert_eq", + zz0551: "nonzero", + zz0552: "skip", + zz0553: "Mod", + zz0554: ")", + zz0555: "TokenTree", + zz0556: "getrandom", + zz0557: "Char", + zz0558: "T5", + zz0559: "Crate", + zz0560: "time_date_stamp", + zz0561: "values", + zz0562: "ret", + zz0563: "'bases", + zz0564: "scopeguard", + zz0565: "guard", + zz0566: "print", + zz0567: "NodeId", + zz0568: "InlineAsm", + zz0569: "FromStr", + zz0570: "current", + zz0571: "Impl", + zz0572: "debug_assert", + zz0573: "Projection", + zz0574: "Arm", + zz0575: "libstd_sys_internals", + zz0576: "SidStart", + zz0577: "DiagnosticBuilder", + zz0578: "Visibility", + zz0579: "lint", + zz0580: "Occupied", + zz0581: "rand_core", + zz0582: "LOCAL_CRATE", + zz0583: "symbols", + zz0584: "find", + zz0585: "Token", + zz0586: "Str", + zz0587: "typenum", + zz0588: "Vacant", + zz0589: "0.7.0", + zz0590: "TokenStream", + zz0591: "18", + zz0592: "DrainFilter", + zz0593: "Entry", + zz0594: "QueryDescription", + zz0595: "Not", + zz0596: " use std::collections::HashSet;", + zz0597: "Res", + zz0598: "pred", + zz0599: "17", + zz0600: "rustc_index::newtype_index", + zz0601: "krate", + zz0602: "handle", + zz0603: "TraitRef", + zz0604: "Normal", + zz0605: "Session", + zz0606: "4.", + zz0607: "string", + zz0608: "code", + zz0609: "impl IntoQueryParam", + zz0610: "Drop", + zz0611: "__m512", + zz0612: "indexmap", + zz0613: "20", + zz0614: "ppv_lite86", + zz0615: "__m512d", + zz0616: "desc", + zz0617: "avx", + zz0618: "additional", + zz0619: "31", + zz0620: "BinOpKind", + zz0621: "Operand", + zz0622: "dest", + zz0623: "l", + zz0624: "Match", + zz0625: "parking_lot", + zz0626: "UnsafeCell", + zz0627: "InlineAsmOperand", + zz0628: "'__lifted", + zz0629: "Length", + zz0630: "generic_array", + zz0631: "'input", + zz0632: "haystack", + zz0633: "moved to rand_distr crate", + zz0634: "try_fold", + zz0635: "instant", + zz0636: "lock_api", + zz0637: "1.12.0", + zz0638: "parking_lot_core", + zz0639: "No", + zz0640: "BorrowKind", + zz0641: "LlvmInlineAsm", + zz0642: "rustc_attr", + zz0643: " [`HashSet`]: struct.HashSet.html", + zz0644: "rustc_lexer", + zz0645: "rustc_arena", + zz0646: "Cell", + zz0647: "internal to format_args!", + zz0648: "19", + zz0649: "rustc_hash", + zz0650: "first", + zz0651: "TyDecoder", + zz0652: "BytePos", + zz0653: "30", + zz0654: "terminator", + zz0655: "T4", + zz0656: "remove_dir_all", + zz0657: "Variant", + zz0658: " unsafe {", + zz0659: "Coff", + zz0660: "min", + zz0661: "fs", + zz0662: "TyEncoder", + zz0663: "Infer", + zz0664: "jobserver", + zz0665: "tracing_attributes", + zz0666: "__lifted", + zz0667: "get_unchecked", + zz0668: "info", + zz0669: "Fold", + zz0670: "root", + zz0671: "24", + zz0672: "try_from", + zz0673: "avx2", + zz0674: "rand_chacha", + zz0675: "rand_pcg", + zz0676: "MultiSpan", + zz0677: "rand", + zz0678: "region", + zz0679: "rustc_graphviz", + zz0680: "Placeholder", + zz0681: "OsStr", + zz0682: "digest", + zz0683: "'t", + zz0684: "mask", + zz0685: "__mmask8", + zz0686: "arrayvec", + zz0687: "from_u32", + zz0688: "measureme", + zz0689: "tracing_core", + zz0690: "28", + zz0691: "25", + zz0692: "22", + zz0693: "replace", + zz0694: "scoped_cx", + zz0695: "1.47.0", + zz0696: " # Errors", + zz0697: "opaque_debug", + zz0698: "26", + zz0699: "Map", + zz0700: " fn main() {", + zz0701: "Lock", + zz0702: "Data", + zz0703: "acc", + zz0704: "next_back", + zz0705: "missing_docs", + zz0706: "cap", + zz0707: "Generics", + zz0708: "21", + zz0709: "block_buffer", + zz0710: "23", + zz0711: "buffer", + zz0712: "Abi", + zz0713: "stacker", + zz0714: "is_anon", + zz0715: "psm", + zz0716: "Args", + zz0717: "29", + zz0718: "tempfile", + zz0719: "27", + zz0720: "IndexMut", + zz0721: "Async", + zz0722: "ena", + zz0723: "take", + zz0724: "Lazy", + zz0725: "Yes", + zz0726: "GenericParam", + zz0727: "rustc_expand", + zz0728: "$crate::cfg", + zz0729: "Owned", + zz0730: "features", + zz0731: "Internal", + zz0732: "'mir", + zz0733: "missing_debug_implementations", + zz0734: "LangItem", + zz0735: "g", + zz0736: "Allocator", + zz0737: "__self_0_4", + zz0738: "TryFrom", + zz0739: "0xFFFF_FF00", + zz0740: "stable_deref_trait", + zz0741: "Rvalue", + zz0742: "$crate::assert", + zz0743: "unicode_width", + zz0744: "Literal", + zz0745: "siphasher", + zz0746: "Stmt", + zz0747: " (provided by the `IntoIterator` trait). See its documentation for more.", + zz0748: "Once", + zz0749: "types", + zz0750: "inputs", + zz0751: "cpuid_bool", + zz0752: "Bool", + zz0753: "dep_node", + zz0754: " {", + zz0755: "Repeat", + zz0756: "integer_atomics_stable", + zz0757: "List", + zz0758: "1.21.0", + zz0759: "it", + zz0760: "BTreeMap", + zz0761: "rustc_lint_defs", + zz0762: "sha1", + zz0763: "variant", + zz0764: "debug_format", + zz0765: "SeqCst", + zz0766: "is_eval_always", + zz0767: "Binary", + zz0768: "$crate::assert_eq", + zz0769: "remove", + zz0770: "GlobalAsm", + zz0771: " fn main() -> std::io::Result<()> {", + zz0772: "md5", + zz0773: "fn_sig", + zz0774: "1.15.0", + zz0775: "ToOwned", + zz0776: "predicates", + zz0777: "1.50.0", + zz0778: "Edition", + zz0779: "arch", + zz0780: "TimeDateStamp", + zz0781: "T3", + zz0782: "Split", + zz0783: "hcx", + zz0784: "Stored", + zz0785: "num", + zz0786: "pointer_methods", + zz0787: "Sub", + zz0788: "ForeignItem", + zz0789: "get_unchecked_mut", + zz0790: "UnOp", + zz0791: "100", + zz0792: "phf_shared", + zz0793: "hash_builder", + zz0794: "const_ptr_offset", + zz0795: "atomic_int", + zz0796: "AnonConst", + zz0797: "read", + zz0798: "Continue", + zz0799: "chunk_size", + zz0800: "scoped_tls", + zz0801: "assert_eq_m128i", + zz0802: "1.31.0", + zz0803: "rounding", + zz0804: "StmtKind", + zz0805: "Opaque", + zz0806: "text", + zz0807: "GenericParamKind", + zz0808: "Name", + zz0809: "FnSig", + zz0810: "FileName", + zz0811: "peel", + zz0812: "list", + zz0813: "is_some", + zz0814: "addr", + zz0815: "hi", + zz0816: "Fingerprint", + zz0817: " use std::io::prelude::*;", + zz0818: "Call", + zz0819: "dummy", + zz0820: "NAME", + zz0821: "empty", + zz0822: "OsString", + zz0823: "RefCell", + zz0824: "__mmask16", + zz0825: "Group", + zz0826: "rustc_feature", + zz0827: "phf", + zz0828: "ManuallyDrop", + zz0829: "imm4", + zz0830: "with_no_trimmed_paths", + zz0831: " impl fmt::Debug for Foo {", + zz0832: " book_reviews.insert(", + zz0833: "sha2", + zz0834: "reserve", + zz0835: "DWORD", + zz0836: "CacheSelector", + zz0837: "origin", + zz0838: "Mut", + zz0839: "characteristics", + zz0840: "graph", + zz0841: "macros", + zz0842: "decoder", + zz0843: "71499", + zz0844: "arena", + zz0845: "obligations", + zz0846: "Visitor", + zz0847: "instance", + zz0848: " Behavior is undefined if any of the following conditions are violated:", + zz0849: "PolyTraitRef", + zz0850: "ecx", + zz0851: "$crate::cfg_if", + zz0852: "fieldset", + zz0853: "decl", + zz0854: "missing_inline_in_public_items", + zz0855: "TypeFolder", + zz0856: "config", + zz0857: "Guard", + zz0858: "PathSegment", + zz0859: "MacroDef", + zz0860: " An integer type which can be safely shared between threads.", + zz0861: " This type has the same in-memory representation as the underlying", + zz0862: " integer type, [`", + zz0863: " ). For more about the differences between atomic types and", + zz0864: " non-atomic types as well as information about the portability of", + zz0865: " this type, please see the [module-level documentation].", + zz0866: " **Note:** This type is only available on platforms that support", + zz0867: " atomic loads and stores of [`", + zz0868: " ).", + zz0869: " [module-level documentation]: crate::sync::atomic", + zz0870: "dwFlags", + zz0871: "1.44.0", + zz0872: "Dynamic", + zz0873: "RangeBounds", + zz0874: "FnDef", + zz0875: "1.43.0", + zz0876: "Any", + zz0877: "T2", + zz0878: " use std::fs::File;", + zz0879: "iterator", + zz0880: "from_u32_unchecked", + zz0881: "fcx", + zz0882: "unsafety", + zz0883: "1.48.0", + zz0884: "template", + zz0885: "rustc_ast_pretty", + zz0886: "query_helper_param_ty", + zz0887: "1.29.0", + zz0888: "returns a new pointer rather than modifying its argument", + zz0889: "adt_def", + zz0890: "endian", + zz0891: "VariantData", + zz0892: "with_capacity", + zz0893: "Mutex", + zz0894: "File", + zz0895: "diag", + zz0896: "Version", + zz0897: "clear", + zz0898: "folder", + zz0899: "scope", + zz0900: "old", + zz0901: "Read", + zz0902: "borrow_mut", + zz0903: "Or", + zz0904: "assert_eq_m256i", + zz0905: "Duration", + zz0906: "depth", + zz0907: "ExpnId", + zz0908: "TrustedLen", + zz0909: "derives", + zz0910: "Section", + zz0911: "Values", + zz0912: "discriminant", + zz0913: "1.25.0", + zz0914: "Borrowed", + zz0915: "display", + zz0916: "assertion failed: `(left == right)`", + zz0917: "prefix", + zz0918: "DropGuard", + zz0919: "1.33.0", + zz0920: "allocator_api", + zz0921: "as_mut_ptr", + zz0922: "StatementKind", + zz0923: "1.42.0", + zz0924: "1.30.0", + zz0925: "unicode_xid", + zz0926: "Never", + zz0927: "GenericBound", + zz0928: "cloned", + zz0929: "default_span", + zz0930: "from_iter", + zz0931: "style", + zz0932: "once_cell", + zz0933: " ```should_panic", + zz0934: "to", + zz0935: "Bytes", + zz0936: "v2", + zz0937: "AtomicUsize", + zz0938: "intravisit", + zz0939: "5.", + zz0940: "Leaf", + zz0941: "Enum", + zz0942: "variants", + zz0943: "6.", + zz0944: "ctxt", + zz0945: "Uint", + zz0946: " use std::sync::Arc;", + zz0947: "cb", + zz0948: "sys", + zz0949: "NAN", + zz0950: "ch", + zz0951: "query_crate", + zz0952: "Handle", + zz0953: "I64", + zz0954: "FnDecl", + zz0955: "TryReserveError", + zz0956: "phantom", + zz0957: "OpaqueTy", + zz0958: "Ptr", + zz0959: "IntTy", + zz0960: "w", + zz0961: "F64", + zz0962: "edition", + zz0963: "'f", + zz0964: "GenericArgKind", + zz0965: "Defaultness", + zz0966: "Shl", + zz0967: "trace", + zz0968: "time", + zz0969: "enumerate", + zz0970: "`,", + zz0971: "Elf", + zz0972: "provider", + zz0973: "encoding", + zz0974: "shr_impl", + zz0975: "PredicateAtom", + zz0976: "__self_1_2", + zz0977: "TypeVisitor", + zz0978: "AsInner", + zz0979: "tag", + zz0980: "word", + zz0981: "Assign", + zz0982: "body_id", + zz0983: "copied", + zz0984: "visit", + zz0985: "order", + zz0986: "swap", + zz0987: "repeat", + zz0988: "params", + zz0989: "Cast", + zz0990: "cnum", + zz0991: "exp", + zz0992: "Unsafe", + zz0993: "sse", + zz0994: "c_void", + zz0995: "LitKind", + zz0996: "AssocItemKind", + zz0997: " It is part of the [`Entry`] enum.", + zz0998: "Included", + zz0999: "ForeignItemKind", + zz1000: "this returns the result of the operation, without modifying the original", + zz1001: "mode", + zz1002: "Paren", + zz1003: "byte", + zz1004: "Gt", + zz1005: "pattern", + zz1006: " This intrinsic does not have a stable counterpart.", + zz1007: "is_none", + zz1008: "U32", + zz1009: "__self_0_5", + zz1010: "1.46.0", + zz1011: "reserved", + zz1012: "P0", + zz1013: "visit_ty", + zz1014: "unwrap_or_else", + zz1015: "Elf32", + zz1016: "Elf64", + zz1017: "MachO32", + zz1018: "MachO64", + zz1019: "Pe32", + zz1020: "Pe64", + zz1021: "Unsize", + zz1022: "CRATE_DEF_INDEX", + zz1023: "1.45.0", + zz1024: "nested", + zz1025: "thread_local_internals", + zz1026: "ObligationCause", + zz1027: "Unpin", + zz1028: "CoerceUnsized", + zz1029: "pop", + zz1030: "join", + zz1031: "FnRetTy", + zz1032: "VisibilityKind", + zz1033: " // ...", + zz1034: "UintTy", + zz1035: "ctrl", + zz1036: "StructField", + zz1037: " use std::collections::BTreeMap;", + zz1038: "Raw", + zz1039: "WhereClause", + zz1040: "infer", + zz1041: "parse", + zz1042: "impls", + zz1043: "loc", + zz1044: "Pattern", + zz1045: "Foreign", + zz1046: "to_def_id", + zz1047: "Shr", + zz1048: "AngleBracketed", + zz1049: "debug_assert_ne", + zz1050: "AddAssign", + zz1051: "filter", + zz1052: "0b11111111", + zz1053: "I32", + zz1054: "TraitBoundModifier", + zz1055: "Parenthesized", + zz1056: "Use", + zz1057: "slice_ptr_get", + zz1058: "Mul", + zz1059: "VariantIdx", + zz1060: " use hashbrown::HashSet;", + zz1061: "cell", + zz1062: "const_wrapping_math", + zz1063: "Receiver", + zz1064: "write_str", + zz1065: "InferCtxt", + zz1066: " thread::spawn(move || {", + zz1067: "WherePredicate", + zz1068: "TraitItem", + zz1069: "RwLock", + zz1070: "SourceMap", + zz1071: "ExactSizeIterator", + zz1072: "segment", + zz1073: "__binding_4", + zz1074: "type_of", + zz1075: "ParamEnv", + zz1076: "ProjectionElem", + zz1077: "expression", + zz1078: "I16", + zz1079: "F32", + zz1080: "Wrapping", + zz1081: "builtin_macro_prelude", + zz1082: "Reject", + zz1083: "Buffer", + zz1084: "Binder", + zz1085: "hint", + zz1086: "I8", + zz1087: "mutbl", + zz1088: "BorrowMut", + zz1089: "FieldPat", + zz1090: "DoubleEndedIterator", + zz1091: "Diagnostic", + zz1092: "ForeignMod", + zz1093: "RangeEnd", + zz1094: "1.35.0", + zz1095: "into_inner", + zz1096: "Reserved1", + zz1097: " >", + zz1098: "ImplPolarity", + zz1099: "job", + zz1100: "1.37.0", + zz1101: "ImplItem", + zz1102: "UserProvided", + zz1103: "Zero", + zz1104: "scale", + zz1105: "to_owned", + zz1106: "verify-winapi", + zz1107: "__session_diagnostic_sess", + zz1108: "Context", + zz1109: "BitSet", + zz1110: "typeck_results", + zz1111: "Unevaluated", + zz1112: "CompilerGenerated", + zz1113: "futures_api", + zz1114: "7.", + zz1115: "subst", + zz1116: "profiler", + zz1117: "as_f64x8", + zz1118: "Keys", + zz1119: "BlockCheckMode", + zz1120: "RawPtr", + zz1121: "DiscriminantKind", + zz1122: "NodeType", + zz1123: "GenericArgs", + zz1124: "as_slice", + zz1125: "util", + zz1126: "8.", + zz1127: "typ", + zz1128: "getopts", + zz1129: "as_f32x16", + zz1130: "Reserved2", + zz1131: "BitFields", + zz1132: "Attributes", + zz1133: "span_bug", + zz1134: "TraitAlias", + zz1135: "SliceIndex", + zz1136: "TRACE", + zz1137: "MetaItem", + zz1138: "Excluded", + zz1139: "check", + zz1140: "32838", + zz1141: "_mm_setr_ps", + zz1142: "_mm512_setzero_si512", + zz1143: "bb", + zz1144: " `count` is in units of T; e.g., a `count` of 3 represents a pointer", + zz1145: " offset of `3 * size_of::()` bytes.", + zz1146: "__iterator_get_unchecked", + zz1147: "segments", + zz1148: "as_u32", + zz1149: "impl_trait_ref", + zz1150: "projection", + zz1151: "1.24.0", + zz1152: "$crate::format_args_nl", + zz1153: "iter_mut", + zz1154: "tmp", + zz1155: "ok", + zz1156: "MacroKind", + zz1157: "GenericBounds", + zz1158: "signed_nonzero", + zz1159: " Stores a value if the current value is the same as the `old` value.", + zz1160: "split", + zz1161: " system.", + zz1162: "binding", + zz1163: "avx512bw,avx512vl", + zz1164: "__fn_bitflags", + zz1165: "Canonical", + zz1166: "T1", + zz1167: "os", + zz1168: "U64", + zz1169: "41", + zz1170: "Statement", + zz1171: "cast", + zz1172: "elt", + zz1173: "associated_item", + zz1174: "InlineAsmRegOrRegClass", + zz1175: "TyAndLayout", + zz1176: "def_span", + zz1177: "_MM_FROUND_NO_EXC", + zz1178: "NoSolution", + zz1179: "Instance", + zz1180: "74265", + zz1181: "asyncness", + zz1182: " [`char`]: prim@char", + zz1183: "InstanceDef", + zz1184: "element", + zz1185: "avx512vl", + zz1186: "1.19.0", + zz1187: "k1", + zz1188: "Event", + zz1189: "FnHeader", + zz1190: "Div", + zz1191: "Unique", + zz1192: "Lt", + zz1193: "spec", + zz1194: "Ur", + zz1195: "const_math", + zz1196: "edges", + zz1197: "_core", + zz1198: "'p", + zz1199: "Def", + zz1200: "Constant", + zz1201: "consts", + zz1202: "x86_64", + zz1203: "back", + zz1204: "Integer", + zz1205: "spans", + zz1206: "codegen_fn_attrs", + zz1207: "forward", + zz1208: " // Type inference lets us omit an explicit type signature (which", + zz1209: "dwSize", + zz1210: "local_def_id", + zz1211: "10.", + zz1212: "Label", + zz1213: "def_path_str", + zz1214: "lines", + zz1215: " A view into a single entry in a map, which may either be vacant or occupied.", + zz1216: "generator_kind", + zz1217: "hir_owner", + zz1218: "Into", + zz1219: "new_layout", + zz1220: "front", + zz1221: "wrapping", + zz1222: "74465", + zz1223: "BITS", + zz1224: "MutTy", + zz1225: " ### Explanation", + zz1226: " its documentation for more.", + zz1227: "machine", + zz1228: "GeneratorWitness", + zz1229: "__self_0_6", + zz1230: "Builder", + zz1231: "hash_raw_entry", + zz1232: " ### Example", + zz1233: "Done", + zz1234: " use std::path::Path;", + zz1235: " fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {", + zz1236: "Searcher", + zz1237: "OccupiedEntry", + zz1238: "PlaceRef", + zz1239: "cbSize", + zz1240: "$crate::error_code", + zz1241: "FromInner", + zz1242: "Delimited", + zz1243: "rustc_query_system", + zz1244: "UnsafeSource", + zz1245: "EnumDef", + zz1246: "generics_of", + zz1247: " [`Eq`]: https://doc.rust-lang.org/std/cmp/trait.Eq.html", + zz1248: "record", + zz1249: "Bx", + zz1250: "NonZeroUsize", + zz1251: "Invalid", + zz1252: "as_mut", + zz1253: "new API", + zz1254: " let mut iter = a.iter();", + zz1255: "Providers", + zz1256: " The stabilized versions of this intrinsic are available on the integer", + zz1257: "o", + zz1258: "ValuesMut", + zz1259: "ClosureKind", + zz1260: "atomic", + zz1261: "compress", + zz1262: "VacantEntry", + zz1263: "AttrVec", + zz1264: "Movability", + zz1265: "RegionVid", + zz1266: "writeln", + zz1267: " [`Hash`]: https://doc.rust-lang.org/std/hash/trait.Hash.html", + zz1268: "lift", + zz1269: " assert_eq!(iter.next(), Some(&2));", + zz1270: "Difference", + zz1271: "Semi", + zz1272: "provide", + zz1273: "push_str", + zz1274: "'__session_diagnostic_sess", + zz1275: "nonnull", + zz1276: " use std::sync::mpsc::channel;", + zz1277: "WhereBoundPredicate", + zz1278: "panic_strategy", + zz1279: "LlvmInlineAsmOutput", + zz1280: "Allow", + zz1281: "48", + zz1282: "Intersection", + zz1283: "FnPtr", + zz1284: " an error.", + zz1285: "int_base", + zz1286: "WhereEqPredicate", + zz1287: "Subst", + zz1288: "const_likely", + zz1289: "WhereRegionPredicate", + zz1290: "SymmetricDifference", + zz1291: "Expression", + zz1292: "Method", + zz1293: "BindingMode", + zz1294: "IntoInner", + zz1295: "magic", + zz1296: "INFO", + zz1297: "crate_disambiguator", + zz1298: "1.0", + zz1299: "found", + zz1300: "__tracing_stringify", + zz1301: "BareFnTy", + zz1302: "AssocItem", + zz1303: " {{produces}}", + zz1304: "BreakTy", + zz1305: "at", + zz1306: "Register", + zz1307: "Loop", + zz1308: "BoundVar", + zz1309: "suffix", + zz1310: "CaptureBy", + zz1311: "try_reserve", + zz1312: "termcolor", + zz1313: "BitAnd", + zz1314: "impl FnMut(&T) -> bool", + zz1315: "base_type", + zz1316: "AtomicRef", + zz1317: "def_kind", + zz1318: "local_decls", + zz1319: "sae", + zz1320: "_mm512_set_epi64", + zz1321: "_mm512_setr_ps", + zz1322: "reserved2", + zz1323: "decode_utf16", + zz1324: " use std::arch::x86::*;", + zz1325: " use std::arch::x86_64::*;", + zz1326: "DepKind", + zz1327: "analysis", + zz1328: "impl_def_id", + zz1329: "_mm_setr_pd", + zz1330: "Inner", + zz1331: "__m256", + zz1332: "Terminator", + zz1333: "DispatchFromDyn", + zz1334: "offsets", + zz1335: "impl Into", + zz1336: "BitXor", + zz1337: " fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {", + zz1338: "LayoutError", + zz1339: " [`Entry`]: enum.Entry.html", + zz1340: "fx", + zz1341: "QPath", + zz1342: "GeneratorKind", + zz1343: "iterator adaptors are lazy and do nothing unless consumed", + zz1344: "_mm_set_ps", + zz1345: "PResult", + zz1346: "as_usize", + zz1347: "_mm512_setr_pd", + zz1348: "trait_def", + zz1349: "chain", + zz1350: "entries", + zz1351: "Scope", + zz1352: "NI", + zz1353: "ExternCrate", + zz1354: "late", + zz1355: "BitOr", + zz1356: " }", + zz1357: "extend_one", + zz1358: "memchr", + zz1359: "_MM_FROUND_CUR_DIRECTION", + zz1360: "BTreeSet", + zz1361: "visit_expr", + zz1362: "Immediate", + zz1363: "ExpnKind", + zz1364: "ct", + zz1365: "IsAuto", + zz1366: "rustc_fs_util", + zz1367: "as_i32x16", + zz1368: "stdout", + zz1369: "group", + zz1370: "SplitN", + zz1371: "ImplicitSelfKind", + zz1372: "new_v1_formatted", + zz1373: "rchunks", + zz1374: "finished", + zz1375: "_mm_set_pd", + zz1376: "And", + zz1377: "ObjectType", + zz1378: "Characteristics", + zz1379: "clSize", + zz1380: "__tcx", + zz1381: "FloatTy", + zz1382: "AtomicU32", + zz1383: "array_impl_default", + zz1384: " # unsafe fn foo() {", + zz1385: "DiagnosticId", + zz1386: "data_layout", + zz1387: "trait_def_id", + zz1388: "EscapeDefault", + zz1389: "RSplit", + zz1390: "ctx", + zz1391: "Dispatch", + zz1392: " // Check for a specific one.", + zz1393: " // Iterate over everything.", + zz1394: "DefIndex", + zz1395: "once", + zz1396: "__bitflags", + zz1397: "ForLoop", + zz1398: "winapi_util", + zz1399: "zip", + zz1400: "_mm512_set_epi32", + zz1401: "cur", + zz1402: "impl_item", + zz1403: "SourceInfo", + zz1404: "SourceIter", + zz1405: "global_alloc", + zz1406: "56167", + zz1407: " A view into an occupied entry in a `HashMap`.", + zz1408: " A view into a vacant entry in a `HashMap`.", + zz1409: "'me", + zz1410: "MethodCall", + zz1411: "candidate", + zz1412: " let arr = [0, 1, 2, 3, 4];", + zz1413: "Successors", + zz1414: ", ", + zz1415: "visited", + zz1416: "Constness", + zz1417: "RSplitN", + zz1418: "snippet", + zz1419: "visibility", + zz1420: "Gated", + zz1421: "LowerHex", + zz1422: " use std::cell::RefCell;", + zz1423: " });", + zz1424: "Align", + zz1425: "RawHandle", + zz1426: "names", + zz1427: "LevelFilter", + zz1428: "is_placeholder", + zz1429: "MacArgs", + zz1430: "from_str", + zz1431: "filter_map", + zz1432: "mem_addr", + zz1433: " [`Hash`] and [`Eq`] on the borrowed form *must* match those for", + zz1434: "Other", + zz1435: "Flag", + zz1436: "If", + zz1437: "Machine", + zz1438: "ReLateBound", + zz1439: "ConstraintCategory", + zz1440: "__m256d", + zz1441: "bound", + zz1442: "COMPARE_PACKED", + zz1443: "atty", + zz1444: "AsRef", + zz1445: "Relaxed", + zz1446: "mid", + zz1447: "arg3", + zz1448: "annotate_snippets", + zz1449: "assert_eq_m512", + zz1450: "item_def_id", + zz1451: "checked_add", + zz1452: "Neg", + zz1453: " for more.", + zz1454: "builder", + zz1455: "is_less", + zz1456: "assert_ne", + zz1457: "bit", + zz1458: "(", + zz1459: "DUMMY_NODE_ID", + zz1460: "InOut", + zz1461: "NonZeroU32", + zz1462: "In", + zz1463: "MetaItemKind", + zz1464: "chars", + zz1465: "assert_eq_m512d", + zz1466: "definitions", + zz1467: "Warn", + zz1468: "typeck", + zz1469: "ConstValue", + zz1470: "j", + zz1471: "Extend", + zz1472: " [valid]: self#safety", + zz1473: " 25", + zz1474: "ErrorKind", + zz1475: "stderr", + zz1476: "cache", + zz1477: "CONTINUE", + zz1478: "load", + zz1479: "Out", + zz1480: "AssignOp", + zz1481: "dep_kind", + zz1482: "{}", + zz1483: "Octal", + zz1484: "exported_symbols", + zz1485: "GeneratorState", + zz1486: "_mm512_set1_epi16", + zz1487: "defaultness", + zz1488: "DepNode", + zz1489: "backtrace", + zz1490: "ExprPrecedence", + zz1491: "Ctxt", + zz1492: "address_size", + zz1493: "rustc_apfloat", + zz1494: "Extern", + zz1495: "Complete", + zz1496: "split_inclusive", + zz1497: "owner", + zz1498: "dep_graph", + zz1499: "'infcx", + zz1500: " ### Note: Windows Portability Consideration", + zz1501: " When operating in a console, the Windows implementation of this stream does not support", + zz1502: "Style", + zz1503: "TokenKind", + zz1504: "z", + zz1505: "Weak", + zz1506: "Seek", + zz1507: "Byte", + zz1508: "128", + zz1509: "SourceFile", + zz1510: "slot", + zz1511: "impl_from", + zz1512: " Can be [used with", + zz1513: " `FallibleIterator`](./index.html#using-with-fallibleiterator).", + zz1514: "destination", + zz1515: "termize", + zz1516: " # #![allow(dead_code)]", + zz1517: "if unused the RwLock will immediately unlock", + zz1518: "ByteStr", + zz1519: "trailing_zeros", + zz1520: "Acquire", + zz1521: "as_i64x8", + zz1522: "Cursor", + zz1523: "Le", + zz1524: "universe", + zz1525: "session", + zz1526: "extra_filename", + zz1527: "from_raw_parts", + zz1528: " assert_eq!(iter.next(), Some(&3));", + zz1529: "DocComment", + zz1530: " every (stack-allocated) variable is considered a separate allocated object.", + zz1531: " #![feature(once_cell)]", + zz1532: "Lint", + zz1533: "sign", + zz1534: " If any of the following conditions are violated, the result is Undefined", + zz1535: " Behavior:", + zz1536: " byte past the end of the same allocated object. Note that in Rust,", + zz1537: " never reach a size where an offset is a concern. For instance, `Vec`", + zz1538: " and `Box` ensure they never allocate more than `isize::MAX` bytes, so", + zz1539: " Most platforms fundamentally can't even construct such an allocation.", + zz1540: " For instance, no known 64-bit platform can ever serve a request", + zz1541: " for 263 bytes due to page-table limitations or splitting the address space.", + zz1542: " However, some 32-bit and 16-bit platforms may successfully serve a request for", + zz1543: " more than `isize::MAX` bytes with things like Physical Address", + zz1544: " Extension. As such, memory acquired directly from allocators or memory", + zz1545: " mapped files *may* be too large to handle with this function.", + zz1546: " let a: HashSet = vec![1, 2, 3].into_iter().collect();", + zz1547: "Parser", + zz1548: "minor_version", + zz1549: "Ge", + zz1550: "factored_offset", + zz1551: "ItemLocalId", + zz1552: "used_trait_imports", + zz1553: "InterpResult", + zz1554: "interned", + zz1555: "33", + zz1556: "recently added", + zz1557: "Single", + zz1558: "Green", + zz1559: "unpack", + zz1560: "Minus", + zz1561: "Instant", + zz1562: "cbData", + zz1563: "u1", + zz1564: "InheritedObjectType", + zz1565: "xSrc", + zz1566: "ySrc", + zz1567: "iUsageSrc", + zz1568: "offBmiSrc", + zz1569: "cbBmiSrc", + zz1570: "offBitsSrc", + zz1571: "cbBitsSrc", + zz1572: "TargetOptions", + zz1573: "predicates_of", + zz1574: "parser", + zz1575: "Ne", + zz1576: "While", + zz1577: "qpath", + zz1578: "imp", + zz1579: "9.", + zz1580: "Feature", + zz1581: "generate_pattern_iterators", + zz1582: "Status", + zz1583: " exists.", + zz1584: "InPlaceIterable", + zz1585: "_MM_PERM_ENUM", + zz1586: "truncate", + zz1587: "newtype_index", + zz1588: "LinkerFlavor", + zz1589: "trait_item", + zz1590: " name: String,", + zz1591: "map_or", + zz1592: "Kind", + zz1593: "Tup", + zz1594: "SelfT", + zz1595: "I128", + zz1596: "CrateType", + zz1597: "region_scope_tree", + zz1598: "indices", + zz1599: " use std::alloc::System;", + zz1600: "c_char", + zz1601: "symbol_name", + zz1602: "Interest", + zz1603: "InlineAsmOptions", + zz1604: "PanicStrategy", + zz1605: "Unsafety", + zz1606: "user_ty", + zz1607: "const_raw_ptr_comparison", + zz1608: "hash_slice", + zz1609: "__mmask32", + zz1610: "copy_slice_and_advance", + zz1611: "CStr", + zz1612: "IoSlice", + zz1613: "MachineApplicable", + zz1614: "Rem", + zz1615: "RefMut", + zz1616: "to_vec", + zz1617: "Macro", + zz1618: "mutability", + zz1619: "normalize_projection_ty", + zz1620: "output_filenames", + zz1621: " use std::time::Duration;", + zz1622: "shrink_to_fit", + zz1623: "AttrStyle", + zz1624: "ByRef", + zz1625: "Chain", + zz1626: "dwFileAttributes", + zz1627: "sections", + zz1628: "inherent_impls", + zz1629: "providers", + zz1630: "ascii", + zz1631: "RawVec", + zz1632: "Packet", + zz1633: "HANDLE", + zz1634: "ParamEnvAnd", + zz1635: "write_fmt", + zz1636: "leading_zeros", + zz1637: "Infallible", + zz1638: "kv", + zz1639: "nodes", + zz1640: "maybe_unused_extern_crates", + zz1641: "retain", + zz1642: "c_uint", + zz1643: "Spanned", + zz1644: "dropck_outlives", + zz1645: "x86", + zz1646: "UpperHex", + zz1647: "DefPathHash", + zz1648: "associated_items", + zz1649: "ImplSource", + zz1650: "codegen_unit", + zz1651: "impl Fn(&T) -> u64", + zz1652: "undo_log", + zz1653: "relate", + zz1654: "rev", + zz1655: "as_inner", + zz1656: "height", + zz1657: "Fallible", + zz1658: "Constraint", + zz1659: " k1 == k2 -> hash(k1) == hash(k2)", + zz1660: " let slice = ['l', 'o', 'r', 'e', 'm'];", + zz1661: "bucket", + zz1662: "static_assert_size", + zz1663: "NestedMetaItem", + zz1664: "BodyId", + zz1665: "debugging_opts", + zz1666: "foreign_modules", + zz1667: "0.0", + zz1668: "pad", + zz1669: "71146", + zz1670: " In other words, if two keys are equal, their hashes must be equal.", + zz1671: " #[derive(Hash, Eq, PartialEq, Debug)]", + zz1672: " struct Viking {", + zz1673: " It is part of the [`RawEntryMut`] enum.", + zz1674: "SyntaxContext", + zz1675: "symbol_mangling_version", + zz1676: "coverageinfo", + zz1677: "implied_outlives_bounds", + zz1678: "40", + zz1679: " dropped.", + zz1680: " together.", + zz1681: "drain_filter", + zz1682: "Callsite", + zz1683: "diagnostics", + zz1684: "ObligationCauseCode", + zz1685: "NonZeroU64", + zz1686: "Release", + zz1687: "VecDeque", + zz1688: "mutex", + zz1689: "space", + zz1690: "Object", + zz1691: "keys", + zz1692: "span_suggestion", + zz1693: "explicit_item_bounds", + zz1694: "TypeOutlives", + zz1695: "zeroed", + zz1696: "handle_alloc_error", + zz1697: "c_int", + zz1698: "native_libraries", + zz1699: "PrimTy", + zz1700: "rustc_parse", + zz1701: " # #[allow(dead_code)]", + zz1702: "upper", + zz1703: " let mut map: HashMap<&str, u32> = HashMap::new();", + zz1704: "CrateDisambiguator", + zz1705: "Namespace", + zz1706: "ImplItemKind", + zz1707: "operand", + zz1708: " assert_eq!(arr[ .. 3], [0, 1, 2 ]);", + zz1709: " assert_eq!(arr[ ..=3], [0, 1, 2, 3 ]);", + zz1710: " assert_eq!(arr[1.. ], [ 1, 2, 3, 4]);", + zz1711: " assert_eq!(arr[1.. 3], [ 1, 2 ]);", + zz1712: " assert_eq!(arr[1..=3], [ 1, 2, 3 ]);", + zz1713: " assert_eq!(arr[ .. ], [0, 1, 2, 3, 4]);", + zz1714: "Cycle", + zz1715: "relocations", + zz1716: "Colon", + zz1717: " [`IndexSet`]: struct.IndexSet.html", + zz1718: "TraitCandidate", + zz1719: "checked_sub", + zz1720: "HandleType", + zz1721: "poison", + zz1722: "Virtual", + zz1723: "Mode", + zz1724: "constness", + zz1725: "method", + zz1726: "slice_index_methods", + zz1727: " An iterator over subslices separated by elements that match a predicate", + zz1728: "_mm512_set1_ps", + zz1729: "status", + zz1730: "Initializer", + zz1731: " [`IndexMap`]: struct.IndexMap.html", + zz1732: "evaluate_obligation", + zz1733: "control_flow_enum", + zz1734: " ```compile_fail,E0277", + zz1735: "Linkage", + zz1736: "lifetimes", + zz1737: "GeneratorLayout", + zz1738: "derive_eq", + zz1739: "mac", + zz1740: "'c", + zz1741: "UndoLog", + zz1742: "crate_hash", + zz1743: "opt", + zz1744: " let mut slice = ['l', 'o', 'r', 'e', 'm'];", + zz1745: "_MM_FROUND_TO_NEAREST_INT", + zz1746: "ConstKind", + zz1747: "const_option", + zz1748: "lookup", + zz1749: "Await", + zz1750: "trimmed_def_paths", + zz1751: "extern_crate", + zz1752: "canonical", + zz1753: "BrNamed", + zz1754: "TypeError", + zz1755: "op_assign_traits", + zz1756: "1.41.0", + zz1757: "try_borrow", + zz1758: "nth_back", + zz1759: "map_into_keys_values", + zz1760: "DesugaringKind", + zz1761: "upvars_mentioned", + zz1762: "Annotatable", + zz1763: "46", + zz1764: "TrustedRandomAccess", + zz1765: "println", + zz1766: "Obligation", + zz1767: "TraitItemKind", + zz1768: "privacy_access_levels", + zz1769: "object_safety_violations", + zz1770: "from_raw_parts_mut", + zz1771: " assert_eq!(None, iter.next());", + zz1772: "assert_eq_m128", + zz1773: "thread_id", + zz1774: "RawEntryMut", + zz1775: "FatalError", + zz1776: "Upvar", + zz1777: "mir_keys", + zz1778: "non_snake_case", + zz1779: "normalize_generic_arg_after_erasing_regions", + zz1780: "'sess", + zz1781: "from_utf8_unchecked", + zz1782: "_mm_setzero_si128", + zz1783: "_mm512_set1_pd", + zz1784: "strings", + zz1785: "Note", + zz1786: "Comma", + zz1787: "event_id", + zz1788: "__self_3", + zz1789: "promoted_mir", + zz1790: "parent_scope", + zz1791: "DebugTuple", + zz1792: "errors", + zz1793: "has_global_allocator", + zz1794: "1.11.0", + zz1795: "image_base", + zz1796: "LowPart", + zz1797: "HighPart", + zz1798: "BeginAddress", + zz1799: "Revision", + zz1800: "ControlFlags", + zz1801: "rgbReserved", + zz1802: "xDest", + zz1803: "yDest", + zz1804: "MAX_EXP", + zz1805: "common", + zz1806: "with", + zz1807: "append", + zz1808: "unsafety_check_result", + zz1809: "all_traits", + zz1810: "unused_generic_params", + zz1811: "GeneratorSavedLocal", + zz1812: "FpCategory", + zz1813: "36", + zz1814: "new_size", + zz1815: " #![feature(allocator_api)]", + zz1816: "Brace", + zz1817: "__arg_1_2", + zz1818: "Move", + zz1819: "dominators", + zz1820: "to_le", + zz1821: "_mm_set1_epi16", + zz1822: "edge", + zz1823: "help", + zz1824: "$crate::quote_each_token", + zz1825: "$crate::quote_tokens_with_context", + zz1826: "Restricted", + zz1827: "ExpnData", + zz1828: "LifetimeName", + zz1829: "num_cpus", + zz1830: "Subtype", + zz1831: "..", + zz1832: "x23", + zz1833: "catch_unwind", + zz1834: "buckets", + zz1835: "__binding_5", + zz1836: "AttrItem", + zz1837: "53020", + zz1838: "100.", + zz1839: "build", + zz1840: " Returns the corresponding `DefId` for the lang item if it", + zz1841: "index_hir", + zz1842: "layout_raw", + zz1843: "checked_mul", + zz1844: "DebugStruct", + zz1845: "Json", + zz1846: "hir_owner_nodes", + zz1847: "entry_fn", + zz1848: "plugin_registrar_fn", + zz1849: "diagnostic_items", + zz1850: "const_checked_int_methods", + zz1851: "slice_from_raw_parts", + zz1852: "new_len", + zz1853: "node_id", + zz1854: "MacDelimiter", + zz1855: "def_reg_class", + zz1856: "def_regs", + zz1857: "expn_that_defined", + zz1858: "impl_polarity", + zz1859: "type_op_subtype", + zz1860: "type_op_normalize_ty", + zz1861: "type_op_normalize_predicate", + zz1862: "type_op_normalize_poly_fn_sig", + zz1863: "type_op_normalize_fn_sig", + zz1864: "Allocation", + zz1865: "Skip", + zz1866: "_mm256_set1_epi16", + zz1867: "collections", + zz1868: "shrink_to", + zz1869: "Snapshot", + zz1870: "SplitInOut", + zz1871: "AttrKind", + zz1872: "All", + zz1873: "all_local_trait_impls", + zz1874: "proc_macro_decls_static", + zz1875: "used_crate_source", + zz1876: "from_ref", + zz1877: "42", + zz1878: "AsRawHandle", + zz1879: "lift_to_tcx", + zz1880: "expn_data", + zz1881: "trigger_delay_span_bug", + zz1882: "optimized_mir", + zz1883: "normalize_opaque_types", + zz1884: "INFINITY", + zz1885: "34", + zz1886: "diff", + zz1887: "flatten", + zz1888: "extend_reserve", + zz1889: "v0", + zz1890: "needle", + zz1891: "BufRead", + zz1892: "check_sum", + zz1893: "BaseAddress", + zz1894: "Binding", + zz1895: "Ul", + zz1896: "Unstable", + zz1897: "NativeLibKind", + zz1898: "interpret", + zz1899: "dependency_formats", + zz1900: "fma", + zz1901: "q", + zz1902: "compare", + zz1903: " #", + zz1904: "62", + zz1905: "S3", + zz1906: "FN", + zz1907: "InlineAsmTemplatePiece", + zz1908: "coerce_unsized_info", + zz1909: "original_crate_name", + zz1910: "reverse", + zz1911: "flag", + zz1912: "by_ref", + zz1913: "hasher_write", + zz1914: "_mm_set1_epi8", + zz1915: "size_of_data", + zz1916: "reserved1", + zz1917: "major_version", + zz1918: "reserved3", + zz1919: "begin_address", + zz1920: "MachO", + zz1921: " > ", + zz1922: " > ", + zz1923: "Active", + zz1924: "sm", + zz1925: "item_bounds", + zz1926: "is_foreign_item", + zz1927: "vtable_methods", + zz1928: "missing_lang_items", + zz1929: "wrapping_neg", + zz1930: "1.18.0", + zz1931: "Short", + zz1932: "MutexGuard", + zz1933: "time2", + zz1934: "'l", + zz1935: "S4", + zz1936: "is_compiler_builtins", + zz1937: "type_implements_trait", + zz1938: "selcx", + zz1939: "50", + zz1940: " use std::rc::Rc;", + zz1941: "DebugList", + zz1942: "Condvar", + zz1943: "Disconnected", + zz1944: "statements", + zz1945: "associated_item_def_ids", + zz1946: "trait_of_item", + zz1947: "is_no_builtins", + zz1948: "vid", + zz1949: "Source", + zz1950: "assert_eq_m128d", + zz1951: "mir_const_qualif", + zz1952: "is_const_fn_raw", + zz1953: "destructure_const", + zz1954: "has_panic_handler", + zz1955: "collect_and_partition_mono_items", + zz1956: "subst_and_check_impossible_predicates", + zz1957: "Overflow", + zz1958: "MIN_EXP", + zz1959: " #![feature(maybe_uninit_ref)]", + zz1960: "Zip", + zz1961: " if there is one, or the `std` crate’s default.", + zz1962: " // type inference lets us omit an explicit type signature (which", + zz1963: "IntoRawHandle", + zz1964: "dispatcher", + zz1965: "Number", + zz1966: "pluralize", + zz1967: "MaybeIncorrect", + zz1968: "covered_file_name", + zz1969: "super_predicates_of", + zz1970: "dylib_dependency_formats", + zz1971: "BasicBlockData", + zz1972: "a_is_expected", + zz1973: "38", + zz1974: "prev", + zz1975: "Matches", + zz1976: " assert_eq!(vec.capacity(), 10);", + zz1977: " use std::net::TcpStream;", + zz1978: "Reg", + zz1979: "codegen_fulfill_obligation", + zz1980: "cond", + zz1981: "is_ascii", + zz1982: "parts", + zz1983: "$crate::assert_ne", + zz1984: "ftCreationTime", + zz1985: "ftLastAccessTime", + zz1986: "ftLastWriteTime", + zz1987: "nFileSizeHigh", + zz1988: "nFileSizeLow", + zz1989: "prev_index", + zz1990: "explicit_predicates_of", + zz1991: "check_match", + zz1992: "lookup_stability", + zz1993: "reachable_non_generics", + zz1994: "supported_target_features", + zz1995: "ReVar", + zz1996: "63", + zz1997: "succ", + zz1998: "str_internals", + zz1999: "ns", + zz2000: "lit", + zz2001: "Let", + zz2002: "Explicit", + zz2003: "is_panic_runtime", + zz2004: "variances_of", + zz2005: "has_typeck_results", + zz2006: "is_mir_available", + zz2007: "SubAssign", + zz2008: "span_err", + zz2009: " ```edition2018", + zz2010: "CtorKind", + zz2011: "mir_borrowck", + zz2012: "visible_parent_map", + zz2013: "chalk_solve", + zz2014: " } else {", + zz2015: "SystemTime", + zz2016: " use std::process::Command;", + zz2017: "signature", + zz2018: "visit_item", + zz2019: "WARN", + zz2020: "CharPos", + zz2021: "Predicate", + zz2022: "inferred_outlives_of", + zz2023: "static_mutability", + zz2024: "is_reachable_non_generic", + zz2025: "1.23.0", + zz2026: "strip_prefix", + zz2027: "rc", + zz2028: "strong", + zz2029: "$crate::__thread_local_inner", + zz2030: "U16", + zz2031: "Unary", + zz2032: "rustc_macros.dz1d4fdj-fallback.cgu", + zz2033: "5evatxee7h6m2cga", + zz2034: "Subscriber", + zz2035: "level_enabled", + zz2036: "opt_const_param_of", + zz2037: "lookup_const_stability", + zz2038: "internal", + zz2039: "engine", + zz2040: "mir_const", + zz2041: "mir_abstract_const", + zz2042: "impl_defaultness", + zz2043: ":", + zz2044: "35", + zz2045: "as_mut_slice", + zz2046: "OnceCell", + zz2047: "StrStyle", + zz2048: "OpenDelim", + zz2049: "variant_index", + zz2050: "mir_promoted", + zz2051: "covered_code_regions", + zz2052: "deref_const", + zz2053: "param_env_reveal_all_normalized", + zz2054: "specializes", + zz2055: "check_item_well_formed", + zz2056: "Module", + zz2057: " * Both the starting and resulting pointer must be either in bounds or one", + zz2058: " The compiler and standard library generally tries to ensure allocations", + zz2059: " difficult to satisfy. The only advantage of this method is that it", + zz2060: " enables more aggressive compiler optimizations.", + zz2061: "58", + zz2062: "CapacityOverflow", + zz2063: "ErrorHandled", + zz2064: "DefIdMap", + zz2065: "try_unify_abstract_consts", + zz2066: "mir_drops_elaborated_and_const_checked", + zz2067: "optimized_mir_of_const_arg", + zz2068: "adt_destructor", + zz2069: "trait_impls_of", + zz2070: "needs_drop_raw", + zz2071: "item_children", + zz2072: "skip_binder", + zz2073: "as_i16x8", + zz2074: "frame", + zz2075: "Plus", + zz2076: "U8", + zz2077: "OP", + zz2078: "hir_crate", + zz2079: "mir_built", + zz2080: "lint_mod", + zz2081: "check_mod_item_types", + zz2082: "typeck_const_arg", + zz2083: "diagnostic_only_typeck", + zz2084: "eval_to_allocation_raw", + zz2085: "lit_to_const", + zz2086: "lookup_deprecation_entry", + zz2087: "rendered_const", + zz2088: "is_profiler_runtime", + zz2089: "check_trait_item_well_formed", + zz2090: "check_impl_item_well_formed", + zz2091: "resolve_lifetimes", + zz2092: "named_region_map", + zz2093: "method_autoderef_steps", + zz2094: "resolve_instance_of_const_arg", + zz2095: "InternalSubsts", + zz2096: "PredicateObligation", + zz2097: "PointerTag", + zz2098: "DebugMap", + zz2099: "SipHasher13", + zz2100: "v3", + zz2101: "enabled", + zz2102: "elements", + zz2103: "wasm_import_module_map", + zz2104: "unsafe_derive_on_repr_packed", + zz2105: "typeck_item_bodies", + zz2106: "crate_inherent_impls", + zz2107: "eval_to_const_value_raw", + zz2108: "reachable_set", + zz2109: "item_attrs", + zz2110: "specialization_graph_of", + zz2111: "adt_drop_tys", + zz2112: "module_exports", + zz2113: "dllimport_foreign_items", + zz2114: "is_dllimport_foreign_item", + zz2115: "all_crate_nums", + zz2116: "CompareImplMethodObligation", + zz2117: "ifn", + zz2118: "56", + zz2119: "successors", + zz2120: "alloc_layout_extra", + zz2121: "x01", + zz2122: "from_elem", + zz2123: "Abort", + zz2124: "X86", + zz2125: "Svh", + zz2126: "AddrOf", + zz2127: "statement", + zz2128: "LanguageItems", + zz2129: "local_def_id_to_hir_id", + zz2130: "lint_levels", + zz2131: "mir_const_qualif_const_arg", + zz2132: "mir_abstract_const_of_const_arg", + zz2133: "predicates_defined_on", + zz2134: "trait_explicit_predicates_and_bounds", + zz2135: "is_const_impl_raw", + zz2136: "issue33140_self_ty", + zz2137: "check_mod_unstable_api_usage", + zz2138: "check_mod_loops", + zz2139: "check_mod_privacy", + zz2140: "coherent_trait", + zz2141: "mir_borrowck_const_arg", + zz2142: "crate_inherent_impls_overlap_check", + zz2143: "check_private_in_public", + zz2144: "fn_arg_names", + zz2145: "impl_parent", + zz2146: "is_unreachable_local_definition", + zz2147: "upstream_monomorphizations_for", + zz2148: "crate_extern_paths", + zz2149: "extern_mod_stmt_cnum", + zz2150: "get_lib_features", + zz2151: "defined_lib_features", + zz2152: "get_lang_items", + zz2153: "defined_lang_items", + zz2154: "is_codegened_item", + zz2155: "backend_optimization_level", + zz2156: "evaluate_goal", + zz2157: "type_op_ascribe_user_type", + zz2158: "type_op_eq", + zz2159: "type_op_prove_predicate", + zz2160: "resolve_instance", + zz2161: "const_alloc_layout", + zz2162: "boxed", + zz2163: "NodeRef", + zz2164: "IntoKeys", + zz2165: "IntoValues", + zz2166: "Disabled", + zz2167: " the key type.", + zz2168: "hir_module_items", + zz2169: "promoted_mir_of_const_arg", + zz2170: "erase_regions_ty", + zz2171: "type_param_predicates", + zz2172: "adt_sized_constraint", + zz2173: "adt_dtorck_constraint", + zz2174: "is_promotable_const_fn", + zz2175: "crate_variances", + zz2176: "inferred_outlives_crate", + zz2177: "unsafety_check_result_for_const_arg", + zz2178: "check_mod_attrs", + zz2179: "check_mod_const_bodies", + zz2180: "check_mod_naked_functions", + zz2181: "check_mod_intrinsics", + zz2182: "check_mod_liveness", + zz2183: "check_mod_impl_wf", + zz2184: "collect_mod_item_types", + zz2185: "is_copy_raw", + zz2186: "is_sized_raw", + zz2187: "is_freeze_raw", + zz2188: "has_structural_eq_impls", + zz2189: "upstream_monomorphizations", + zz2190: "crate_host_hash", + zz2191: "implementations_of_trait", + zz2192: "is_statically_included_foreign_item", + zz2193: "native_library_kind", + zz2194: "is_late_bound_map", + zz2195: "missing_extern_crate_item", + zz2196: "names_imported_by_glob_use", + zz2197: "instance_def_size_estimate", + zz2198: "cstore", + zz2199: "u2", + zz2200: "col", + zz2201: "DebugSet", + zz2202: "Chars", + zz2203: "_priv", + zz2204: "stream", + zz2205: "S1", + zz2206: "projection_ty_from_predicates", + zz2207: "parent_module_from_def_id", + zz2208: "mir_shims", + zz2209: "in_scope_traits_map", + zz2210: "upstream_drop_glue_for", + zz2211: "all_trait_implementations", + zz2212: "object_lifetime_defaults_map", + zz2213: "all_diagnostic_items", + zz2214: "postorder_cnums", + zz2215: "maybe_unused_trait_import", + zz2216: "stability_index", + zz2217: "features_query", + zz2218: "Coverage", + zz2219: " Formats the value using the given formatter.", + zz2220: "SipHasher", + zz2221: "prev_token", + zz2222: "39", + zz2223: "Discriminant", + zz2224: "elems", + zz2225: "__tracing_log", + zz2226: " use std::cell::Cell;", + zz2227: "_mm256_setzero_si256", + zz2228: "14.", + zz2229: " This `struct` is created by the [`symmetric_difference`] method on", + zz2230: "category", + zz2231: "AggregateKind", + zz2232: "unimplemented", + zz2233: "build_hasher", + zz2234: "outputs", + zz2235: "sse4.1", + zz2236: "stability", + zz2237: "aarch64", + zz2238: "Lines", + zz2239: " seed seed seed seed", + zz2240: "item_id", + zz2241: "from_ne_bytes", + zz2242: "60", + zz2243: "__self_1_3", + zz2244: "ParseError", + zz2245: "ip", + zz2246: "AsInnerMut", + zz2247: "Custom", + zz2248: "Wasm", + zz2249: "37", + zz2250: "AtomicBool", + zz2251: " [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html", + zz2252: "PanicInfo", + zz2253: "str_escape", + zz2254: "int", + zz2255: "OpenOptions", + zz2256: "Stderr", + zz2257: "sig1", + zz2258: "discr", + zz2259: "Extra", + zz2260: "52", + zz2261: "1.14.0", + zz2262: "description", + zz2263: "Blink", + zz2264: "LazyTokenStream", + zz2265: "alloc_id", + zz2266: "relation", + zz2267: "popcnt", + zz2268: "TryInto", + zz2269: "old_layout", + zz2270: "nSize", + zz2271: "sig2", + zz2272: "SESSION_GLOBALS", + zz2273: "AttrId", + zz2274: "BindingAnnotation", + zz2275: "promoted", + zz2276: "PlaceContext", + zz2277: "cmpxchg16b", + zz2278: "constraints", + zz2279: "Stdout", + zz2280: "ImageBase", + zz2281: "tree", + zz2282: "TupleStruct", + zz2283: "LitIntType", + zz2284: "tys", + zz2285: "57", + zz2286: "Memory", + zz2287: "75294", + zz2288: "weak", + zz2289: "LockedPlaceholder", + zz2290: "children", + zz2291: "Erased", + zz2292: "impl_stable_hash_via_hash", + zz2293: "subscriber", + zz2294: "dwReserved", + zz2295: "Flink", + zz2296: "Reserved3", + zz2297: "CheckSum", + zz2298: "MajorVersion", + zz2299: "MinorVersion", + zz2300: "elfLogFont", + zz2301: "elfStyle", + zz2302: "cxDest", + zz2303: "cyDest", + zz2304: "dwRop", + zz2305: "xformSrc", + zz2306: "crBkColorSrc", + zz2307: "cxSrc", + zz2308: "cySrc", + zz2309: "DelimToken", + zz2310: "constraint", + zz2311: "binders", + zz2312: " Performs the conversion.", + zz2313: "Utf8Error", + zz2314: "45", + zz2315: "impl FnMut(T) -> B", + zz2316: "storage", + zz2317: "Unit", + zz2318: "bucket_mask", + zz2319: "DelimSpan", + zz2320: "UseTreeKind", + zz2321: "LocalDecl", + zz2322: "CastKind", + zz2323: "UnsafetyViolationKind", + zz2324: "builtin", + zz2325: " [`&str`]: prim@str", + zz2326: "IoSliceMut", + zz2327: "tts", + zz2328: "intern", + zz2329: "AngleBracketedArg", + zz2330: "CRATE_NODE_ID", + zz2331: "task_deps", + zz2332: "AdtDef", + zz2333: " .finish()", + zz2334: "tv_sec", + zz2335: "S2", + zz2336: "FiniteBitSet", + zz2337: "layout_of", + zz2338: "Negative", + zz2339: "overflowing_add", + zz2340: "unchecked_math", + zz2341: "Step", + zz2342: "Take", + zz2343: "integer", + zz2344: "51", + zz2345: "'iter", + zz2346: "Lifted", + zz2347: "FxIndexMap", + zz2348: "Transparency", + zz2349: "ParamName", + zz2350: "todo", + zz2351: "reverse_bits", + zz2352: "array_chunks", + zz2353: "simd_m_ty", + zz2354: "print_internals", + zz2355: "Warning", + zz2356: "QSelf", + zz2357: "candidates", + zz2358: "CloseDelim", + zz2359: "ConstQualifs", + zz2360: "to_ascii_lowercase", + zz2361: "44", + zz2362: " use std::mem::{self, MaybeUninit};", + zz2363: " See the [module-level documentation](self) for more.", + zz2364: " See: ", + zz2365: "chunks_exact", + zz2366: " An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a", + zz2367: "shift", + zz2368: "55", + zz2369: "2.0", + zz2370: "DebugInfo", + zz2371: "'__a", + zz2372: "outlives", + zz2373: "basic_blocks", + zz2374: "Coercion", + zz2375: "NonZeroI128", + zz2376: "Sign", + zz2377: "Big", + zz2378: "49", + zz2379: "lower", + zz2380: "BuildHasher", + zz2381: " When the slice len is not evenly divided by the chunk size, the last", + zz2382: "EncodeResult", + zz2383: "$crate::which_arena_for_type", + zz2384: "make_ascii_uppercase", + zz2385: "make_ascii_lowercase", + zz2386: "47", + zz2387: " When the slice len is not evenly divided by the chunk size, the last slice", + zz2388: " of the iteration will be the remainder.", + zz2389: "_mm_set1_ps", + zz2390: "Simple", + zz2391: "RwLockWriteGuard", + zz2392: "UseTree", + zz2393: "visit_local", + zz2394: "'graph", + zz2395: "operands", + zz2396: "NonZeroI64", + zz2397: "uint_impl", + zz2398: "Positive", + zz2399: "ZERO", + zz2400: " use std::cell::UnsafeCell;", + zz2401: "pivot", + zz2402: "nanos", + zz2403: "Edge", + zz2404: "MatchSource", + zz2405: "PlaceElem", + zz2406: "core_arch", + zz2407: "NonZeroU128", + zz2408: "NonZeroU8", + zz2409: "59", + zz2410: "EscapeDebug", + zz2411: " function.", + zz2412: " An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size`", + zz2413: "RwLockReadGuard", + zz2414: "bump", + zz2415: "Ctor", + zz2416: "Stable", + zz2417: "Promoted", + zz2418: "GenericParamDefKind", + zz2419: "NonZeroI32", + zz2420: "to_ascii_uppercase", + zz2421: "eq_ignore_ascii_case", + zz2422: "54", + zz2423: "43", + zz2424: "EscapeUnicode", + zz2425: " assert_eq!(iter.next(), Some(&1));", + zz2426: "AcqRel", + zz2427: "starts_with", + zz2428: "filename", + zz2429: "Endian", + zz2430: "visit_foreign_item", + zz2431: "substitution", + zz2432: "Safety", + zz2433: "NonZeroIsize", + zz2434: "as_bytes", + zz2435: "overflowing_mul", + zz2436: "checked_shl", + zz2437: " [`atomic`] types via the `compare_exchange` method by passing", + zz2438: "leaf", + zz2439: "Start", + zz2440: "Command", + zz2441: "Null", + zz2442: "At", + zz2443: "ReferenceOutlivesReferent", + zz2444: "NonZeroU16", + zz2445: "NonZeroI16", + zz2446: " #[repr(C)]", + zz2447: " method.", + zz2448: "arr", + zz2449: "RawEntryBuilder", + zz2450: "RawOccupiedEntryMut", + zz2451: "RawVacantEntryMut", + zz2452: " use std::sync::{Arc, Mutex};", + zz2453: "Md5", + zz2454: "Sha256", + zz2455: "import", + zz2456: "version_check", + zz2457: "WellFormed", + zz2458: "TyVar", + zz2459: "LowerExp", + zz2460: "1.49.0", + zz2461: " {", + zz2462: " ```ignore (extern-declaration)", + zz2463: "Sha1", + zz2464: "scalar", + zz2465: "Destination", + zz2466: "Limit", + zz2467: "projection_ty", + zz2468: "`tcx.", + zz2469: ")` unsupported by its crate", + zz2470: "1.39.0", + zz2471: "NonZeroI8", + zz2472: "TryFromIntError", + zz2473: "tests", + zz2474: "checked_shr", + zz2475: "wrapping_div", + zz2476: " assert!(v.is_empty());", + zz2477: "42327", + zz2478: "panic_hooks", + zz2479: "__mmask64", + zz2480: "eprintln", + zz2481: "RawEntryBuilderMut", + zz2482: " use std::os::raw::c_char;", + zz2483: "rwlock", + zz2484: "SelfKind", + zz2485: "fn_abi", + zz2486: "OpaqueTyOrigin", + zz2487: "OptLevel", + zz2488: "parse_sess", + zz2489: "llfn", + zz2490: "to_ne_bytes", + zz2491: "AtomicIsize", + zz2492: "Unbounded", + zz2493: " [`into_iter`]: IntoIterator::into_iter", + zz2494: "extra", + zz2495: "grow", + zz2496: "SymbolTable", + zz2497: "Mach", + zz2498: "__macro_support", + zz2499: "instrument", + zz2500: "IntType", + zz2501: "from_str_radix", + zz2502: "overflowing_neg", + zz2503: " [`next`]: Iterator::next", + zz2504: " let x: Option<&str> = None;", + zz2505: "store", + zz2506: "_mm512_set1_epi8", + zz2507: "Full", + zz2508: "Sym", + zz2509: "ccx", + zz2510: "ExtCtxt", + zz2511: " use std::path::PathBuf;", + zz2512: "as_i8x16", + zz2513: "_mm_set1_pd", + zz2514: "_mm512_set1_epi64", + zz2515: " let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();", + zz2516: "Category", + zz2517: "GraphSuccessors", + zz2518: "HasDataLayout", + zz2519: "UnsafetyViolationDetails", + zz2520: "ssse3", + zz2521: "53", + zz2522: "_mm256_setr_ps", + zz2523: " non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return", + zz2524: "Mips", + zz2525: "Generic", + zz2526: "try_load_from_disk", + zz2527: "descr", + zz2528: "active", + zz2529: "cgcx", + zz2530: "count_ones", + zz2531: "from_raw", + zz2532: "11.", + zz2533: "13.", + zz2534: "0b00001111", + zz2535: "child", + zz2536: "stdin", + zz2537: "BOOL", + zz2538: "abbreviations", + zz2539: "Info", + zz2540: "StrLit", + zz2541: "AssocTyConstraintKind", + zz2542: "LlvmAsmDialect", + zz2543: "CRATE_HIR_ID", + zz2544: "ProjectionKind", + zz2545: "TraitObject", + zz2546: "writer", + zz2547: "me", + zz2548: "cache_on_disk", + zz2549: " Extracts the value of this index as a `u32`.", + zz2550: "targets", + zz2551: "foreign_item", + zz2552: "polonius_engine", + zz2553: "InferConst", + zz2554: "adt", + zz2555: "bmi1", + zz2556: "from_be_bytes", + zz2557: "IntErrorKind", + zz2558: "St", + zz2559: "step", + zz2560: "Pe", + zz2561: "RangeSyntax", + zz2562: "StructRest", + zz2563: "ExplicitSelf", + zz2564: "LifetimeParamKind", + zz2565: "error_code", + zz2566: "early_error", + zz2567: "TypeAndMut", + zz2568: "'leap", + zz2569: "queue", + zz2570: "Visit", + zz2571: "Always", + zz2572: "AssocTyConstraint", + zz2573: "ParamKindOrd", + zz2574: "BrAnon", + zz2575: "RePlaceholder", + zz2576: "rvalue", + zz2577: "for_each", + zz2578: "detect", + zz2579: "size_of_image", + zz2580: "ConstantIndex", + zz2581: "n_type", + zz2582: "segname", + zz2583: "proc_macro_lib2", + zz2584: "Help", + zz2585: "RangeLimits", + zz2586: "CrateSugar", + zz2587: "AsyncGeneratorKind", + zz2588: "Annotation", + zz2589: "SourceScope", + zz2590: "max_value", + zz2591: "swap_bytes", + zz2592: " }", + zz2593: "ready", + zz2594: "12.", + zz2595: " 42", + zz2596: "delim", + zz2597: "Address", + zz2598: "virtual_address", + zz2599: "instructions", + zz2600: "r_offset", + zz2601: "r_info", + zz2602: "cputype", + zz2603: "cpusubtype", + zz2604: "dl", + zz2605: "BitMatrix", + zz2606: "FnCtxt", + zz2607: "NestedVisitorMap", + zz2608: "ProjectionTy", + zz2609: "ClosureOutlivesRequirement", + zz2610: "chalk_derive", + zz2611: "AtomicI32", + zz2612: " # #![allow(invalid_value)]", + zz2613: " * The computed offset, **in bytes**, cannot overflow an `isize`.", + zz2614: " `vec.as_ptr().add(vec.len())` is always safe.", + zz2615: "from_utf8", + zz2616: "secs", + zz2617: "x1", + zz2618: "ToString", + zz2619: "end_address", + zz2620: " # unreachable!()", + zz2621: "MacStmtStyle", + zz2622: "path_span", + zz2623: "DiagnosticStyledString", + zz2624: "item_name", + zz2625: "ClosureRegionRequirements", + zz2626: "ClosureOutlivesSubject", + zz2627: "AsMut", + zz2628: " use std::ptr::NonNull;", + zz2629: " let ptr: *const u8 = s.as_ptr();", + zz2630: " assert_eq!(result, true);", + zz2631: "unused_comparisons", + zz2632: " [`&str`]: str", + zz2633: "as_i16x32", + zz2634: "_mm512_set1_epi32", + zz2635: " The key may be any borrowed form of the map's key type, but", + zz2636: " //", + zz2637: "System", + zz2638: "Dot", + zz2639: "DotDotEq", + zz2640: "UndoLogs", + zz2641: "as_local", + zz2642: "MacCallStmt", + zz2643: "Eof", + zz2644: "IsAsync", + zz2645: "Atom", + zz2646: "ReturnConstraint", + zz2647: "int_to_from_bytes", + zz2648: "rfind", + zz2649: "55724", + zz2650: "u32x4", + zz2651: "as_f32x4", + zz2652: "_mm256_setr_pd", + zz2653: "flush", + zz2654: "'entry", + zz2655: "AngleBracketedArgs", + zz2656: "TraitFn", + zz2657: "BorrowCheckResult", + zz2658: "ReEarlyBound", + zz2659: "from_bits", + zz2660: "61", + zz2661: "from_mut", + zz2662: "SplitInclusive", + zz2663: "r2", + zz2664: "LinkedList", + zz2665: "SocketAddr", + zz2666: "stmts", + zz2667: "DefaultCacheSelector", + zz2668: "UnsafetyCheckResult", + zz2669: "InferOk", + zz2670: "to_be_bytes", + zz2671: "to_le_bytes", + zz2672: "_mm_set_epi8", + zz2673: "spec_extend", + zz2674: "Frame", + zz2675: "BufWriter", + zz2676: "TcpStream", + zz2677: "rx", + zz2678: "Punct", + zz2679: "Bracket", + zz2680: " Extracts the value of this index as a `usize`.", + zz2681: "UOW", + zz2682: "TypeFlags", + zz2683: "CoverageKind", + zz2684: "ClearCrossCrate", + zz2685: "from_le_bytes", + zz2686: " [ub]: ../../reference/behavior-considered-undefined.html", + zz2687: " Returns a raw pointer to the slice's buffer.", + zz2688: "sum", + zz2689: ": ", + zz2690: "X", + zz2691: "as_i16x16", + zz2692: "SpecExtend", + zz2693: "self_", + zz2694: "LitFloatType", + zz2695: "subexpression", + zz2696: "ReFree", + zz2697: "UniverseIndex", + zz2698: "PointerCast", + zz2699: "LocalKind", + zz2700: "statement_index", + zz2701: "UnsafetyViolation", + zz2702: " use std::cmp::Ordering;", + zz2703: "Enumerate", + zz2704: "__self_0_7", + zz2705: "middle", + zz2706: "HCX", + zz2707: "br", + zz2708: "BodyOwnerKind", + zz2709: "saturating_mul", + zz2710: "gen", + zz2711: " of the allocator registered with the `#[global_allocator]` attribute", + zz2712: " of the [`Global`] type when it and the [`Allocator`] trait become stable.", + zz2713: "local_len", + zz2714: "rng", + zz2715: "Next", + zz2716: "bound_generic_params", + zz2717: "CoverageInfo", + zz2718: "SwitchTargets", + zz2719: "sse3", + zz2720: " #![feature(core_intrinsics)]", + zz2721: "ptr_internals", + zz2722: "Inspect", + zz2723: "Windows", + zz2724: "h", + zz2725: "_mm512_setr_epi32", + zz2726: " // oops, this review has a lot of spelling mistakes, let's delete it.", + zz2727: " // Look up the value for a key (will panic if the key is not found).", + zz2728: " fn random_stat_buff() -> u8 {", + zz2729: " // could actually return some random value here - let's just return", + zz2730: " // some fixed value for now", + zz2731: " // insert a key only if it doesn't already exist", + zz2732: " // insert a key using a function that provides a new value only if it", + zz2733: " // doesn't already exist", + zz2734: " // update a key, guarding against the key possibly not being set", + zz2735: " *stat += random_stat_buff();", + zz2736: "bufs", + zz2737: "'tree", + zz2738: "ParenthesizedArgs", + zz2739: " fn drop(&mut self) {", + zz2740: "try_rfold", + zz2741: " ```{.should_panic}", + zz2742: "as_f64x2", + zz2743: " It is a logic error for an item to be modified in such a way that the", + zz2744: " // Add some books.", + zz2745: " books.len());", + zz2746: " // Remove a book.", + zz2747: " for book in &books {", + zz2748: " use std::ffi::OsStr;", + zz2749: "FromRawHandle", + zz2750: "db", + zz2751: "TraitObjectSyntax", + zz2752: "RelateResult", + zz2753: "k0", + zz2754: " for i in 0..10 {", + zz2755: "enter", + zz2756: "terminated", + zz2757: "Star", + zz2758: "__impl_bitflags", + zz2759: "eval_always", + zz2760: "ThinVec", + zz2761: "OnHit", + zz2762: "OnMiss", + zz2763: "QueryResponse", + zz2764: "ReEmpty", + zz2765: "NEG_INFINITY", + zz2766: "as_ne_bytes", + zz2767: "copy_from_slice", + zz2768: "overflowing_sub", + zz2769: " let v = vec![1, 2, 3];", + zz2770: "into_searcher", + zz2771: "from_inner", + zz2772: "cleanup", + zz2773: "Pound", + zz2774: "Red", + zz2775: "LayoutOf", + zz2776: "rls_data", + zz2777: "xsave", + zz2778: "min_value", + zz2779: "from_be", + zz2780: "div_euclid", + zz2781: "rem_euclid", + zz2782: "fn_traits", + zz2783: "UpperExp", + zz2784: " use std::str;", + zz2785: "future_readiness_fns", + zz2786: "into_vec", + zz2787: " This `enum` is constructed from the [`entry`] method on [`HashMap`].", + zz2788: "dwStreamNumber", + zz2789: "ExceptionRecord", + zz2790: "EvaluationResult", + zz2791: "fallability", + zz2792: "Maybe", + zz2793: "lhs_ty", + zz2794: "DebruijnIndex", + zz2795: "Var", + zz2796: "lazy", + zz2797: "wrapping_shl", + zz2798: "pow", + zz2799: " [`atomic`] types via the `compare_exchange_weak` method by passing", + zz2800: " function returns, or else it will end up pointing to garbage.", + zz2801: " let sparkle_heart = vec![240, 159, 146, 150];", + zz2802: " Example:", + zz2803: "Prefix", + zz2804: "Word", + zz2805: "Question", + zz2806: "SyntheticTyParamKind", + zz2807: "TraitItemId", + zz2808: "ConstContext", + zz2809: "OutputType", + zz2810: "OutputFilenames", + zz2811: "specialization_graph", + zz2812: "assoc_int_consts", + zz2813: "to_be", + zz2814: "niche optimization path", + zz2815: "BitOrAssign", + zz2816: " // some bytes, in a vector", + zz2817: "st_size", + zz2818: "wReserved", + zz2819: "LintId", + zz2820: "ImplItemId", + zz2821: "LocalInfo", + zz2822: "bmi2", + zz2823: " use std::marker::PhantomData;", + zz2824: "rfold", + zz2825: "vtable", + zz2826: "padding", + zz2827: "searcher", + zz2828: "ext", + zz2829: "bitmask", + zz2830: "qself", + zz2831: "Signature", + zz2832: "FileNameLength", + zz2833: "NextEntryOffset", + zz2834: "EndAddress", + zz2835: "PerJobUserTimeLimit", + zz2836: "LimitFlags", + zz2837: "VirtualAddress", + zz2838: "SizeOfImage", + zz2839: "SizeOfData", + zz2840: "bReserved", + zz2841: "MaximumLength", + zz2842: "uliStreamSize", + zz2843: "uliTotalFileSize", + zz2844: "elfFullName", + zz2845: "ihBrush", + zz2846: "llvm_target", + zz2847: "YieldSource", + zz2848: "VarDebugInfo", + zz2849: "checked_div", + zz2850: " }));", + zz2851: "coverage", + zz2852: "def_path_hash", + zz2853: "DestructuredConst", + zz2854: "75744", + zz2855: "Y", + zz2856: "X86_64", + zz2857: "ForLoopLoc", + zz2858: "macro_backtrace", + zz2859: "pointer_width", + zz2860: "LoopSource", + zz2861: "ParseFloatError", + zz2862: "from_le", + zz2863: "immediate", + zz2864: "old_size", + zz2865: "file_name", + zz2866: "TcpListener", + zz2867: "ColorConfig", + zz2868: "GenericParamCount", + zz2869: "ForeignItemId", + zz2870: "ItemId", + zz2871: "LlvmInlineAsmInner", + zz2872: "mono", + zz2873: "fxsr", + zz2874: " [pattern]: self::pattern", + zz2875: "UdpSocket", + zz2876: "Function", + zz2877: "Percent", + zz2878: "__binding_6", + zz2879: "AlwaysRequiresDrop", + zz2880: "'combine", + zz2881: " impl Buffer {", + zz2882: "write_char", + zz2883: "encode_utf16", + zz2884: " An implementation of SipHash 2-4.", + zz2885: "_mm_set_epi64x", + zz2886: "BinaryHeap", + zz2887: "AssertUnwindSafe", + zz2888: " The data protected by the mutex can be accessed through this guard via its", + zz2889: " [`PartialEq`]: https://doc.rust-lang.org/std/cmp/trait.PartialEq.html", + zz2890: "probe_seq", + zz2891: "words", + zz2892: "parallel_compiler", + zz2893: "declare_tool_lint", + zz2894: "pprust", + zz2895: "LocalSource", + zz2896: "ParseIntError", + zz2897: "find_map", + zz2898: "success", + zz2899: "set_span", + zz2900: "Dollar", + zz2901: "span_to_snippet", + zz2902: "BoundPredicate", + zz2903: "ImplItemRef", + zz2904: "PathKind", + zz2905: "InferenceVar", + zz2906: "wrapping_shr", + zz2907: " let c = RefCell::new(5);", + zz2908: "72360", + zz2909: "Piece", + zz2910: "Caret", + zz2911: "SessionDiagnostic", + zz2912: "'g", + zz2913: "Misc", + zz2914: "Subslice", + zz2915: "AssertKind", + zz2916: "ExpectedFound", + zz2917: "accum", + zz2918: "reserve_exact", + zz2919: "contains_key", + zz2920: "Handler", + zz2921: "Spacing", + zz2922: "Tilde", + zz2923: "Slash", + zz2924: "ast_struct", + zz2925: "bit_set", + zz2926: "ConstBlock", + zz2927: "LoopIdError", + zz2928: "flt2dec", + zz2929: ";", + zz2930: "overflowing_div", + zz2931: "overflowing_rem", + zz2932: "BitAndAssign", + zz2933: " let v = [10, 40, 30];", + zz2934: "tm", + zz2935: " It is also a logic error for the [`Hash`] implementation of a key to panic.", + zz2936: " This is generally only possible if the trait is implemented manually. If a", + zz2937: " some items may be dropped from the table.", + zz2938: " [`RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html", + zz2939: " [`Cell`]: https://doc.rust-lang.org/std/cell/struct.Cell.html", + zz2940: " [`RawEntryMut`]: enum.RawEntryMut.html", + zz2941: " A builder for computing where in a [`HashMap`] a key-value pair would be stored.", + zz2942: "SerializedDepNodeIndex", + zz2943: "TraitItemRef", + zz2944: "traversal", + zz2945: "UserTypeProjection", + zz2946: "count_zeros", + zz2947: "overflowing_shl", + zz2948: "overflowing_shr", + zz2949: "checked_pow", + zz2950: "is_null", + zz2951: " use std::ops::RangeBounds;", + zz2952: "fused", + zz2953: "ReverseSearcher", + zz2954: "0b00000000_11111111", + zz2955: "0b0000000011111111", + zz2956: " # Ok(())", + zz2957: "counter", + zz2958: "DirectedGraph", + zz2959: "Deny", + zz2960: "TypeBinding", + zz2961: "TypeBindingKind", + zz2962: "ItemLocalMap", + zz2963: "datafrog", + zz2964: "leading_ones", + zz2965: "trailing_ones", + zz2966: "checked_neg", + zz2967: "overflowing_div_euclid", + zz2968: "wrapping_rem", + zz2969: "overflowing_rem_euclid", + zz2970: "wrapping_pow", + zz2971: "_field", + zz2972: "results", + zz2973: "btree_range", + zz2974: "sep", + zz2975: "Underscore", + zz2976: "visit_pat", + zz2977: "event_kind", + zz2978: "DistinctSources", + zz2979: "Interpolated", + zz2980: "Aggregate", + zz2981: "MethodKind", + zz2982: "arena_types", + zz2983: "annotation_type", + zz2984: "checked_div_euclid", + zz2985: "checked_rem", + zz2986: "checked_rem_euclid", + zz2987: "saturating_pow", + zz2988: "wrapping_div_euclid", + zz2989: "wrapping_rem_euclid", + zz2990: "overflowing_pow", + zz2991: "slice_ptr_len", + zz2992: "array_windows", + zz2993: "hashmap_build_hasher", + zz2994: "color", + zz2995: "domain_size", + zz2996: "Registry", + zz2997: "CachingSourceMapView", + zz2998: "UseKind", + zz2999: "ConstEvaluatable", + zz3000: "IntVar", + zz3001: "46571", + zz3002: "inclusive_range", + zz3003: "Peekable", + zz3004: "use `std::collections::hash_map::DefaultHasher` instead", + zz3005: "i32x4", + zz3006: "_mm256_set1_epi8", + zz3007: " fn main() -> io::Result<()> {", + zz3008: "dropfn", + zz3009: "Public", + zz3010: "blocks", + zz3011: "FnKind", + zz3012: "ForeignItemRef", + zz3013: "AdtSizedConstraint", + zz3014: "RETURN_PLACE", + zz3015: "__a", + zz3016: "rdrand", + zz3017: " An atomic fence.", + zz3018: "Arg", + zz3019: " use std::cmp;", + zz3020: "_private", + zz3021: "Sip24Rounds", + zz3022: "Chunks", + zz3023: "LinesAny", + zz3024: "SplitTerminator", + zz3025: "_mm512_setzero_ps", + zz3026: " let mut vec = vec![1, 2, 3];", + zz3027: "IpAddr", + zz3028: "ExitStatus", + zz3029: "SyncLazy", + zz3030: "ConstArg", + zz3031: "MirPhase", + zz3032: "VarDebugInfoContents", + zz3033: "const_slice_ptr_len", + zz3034: " Subtract from the current value, returning the previous value.", + zz3035: " [`atomic`] types via the `fetch_sub` method by passing", + zz3036: "Copied", + zz3037: "RSplitTerminator", + zz3038: " for _ in 0..10 {", + zz3039: " let mut set = HashSet::new();", + zz3040: "Stdio", + zz3041: "SignedInt", + zz3042: "nightly", + zz3043: "alloc_from_iter", + zz3044: "WithNumNodes", + zz3045: "SsoHashSet", + zz3046: "rustc_type_ir", + zz3047: "MutVisitor", + zz3048: "max_atomic_width", + zz3049: "UserTypeAnnotationIndex", + zz3050: "START_BLOCK", + zz3051: "f16c", + zz3052: " let mut x = MaybeUninit::>::uninit();", + zz3053: "One", + zz3054: "RMatches", + zz3055: "MatchIndices", + zz3056: "RMatchIndices", + zz3057: " The [pattern] can be a `&str`, [`char`], a slice of [`char`]s, or a", + zz3058: " function or closure that determines if a character matches.", + zz3059: "vals", + zz3060: "_mm512_setzero_pd", + zz3061: "from_boxed_utf8_unchecked", + zz3062: "clone_into", + zz3063: "Color", + zz3064: "Base", + zz3065: "InlineAsmRegClass", + zz3066: "OutlivesBound", + zz3067: "ConstEquate", + zz3068: " The stabilized version of this intrinsic is", + zz3069: " use std::collections::hash_map::RandomState;", + zz3070: "BuildHasherDefault", + zz3071: "alloc_layout_manipulation", + zz3072: "15.", + zz3073: "s_no_extra_traits", + zz3074: "shard", + zz3075: "level_filters", + zz3076: "to_ty", + zz3077: "OverflowError", + zz3078: "AllocId", + zz3079: "FloatVar", + zz3080: "llval", + zz3081: "lzcnt", + zz3082: "Fuse", + zz3083: "ends_with", + zz3084: "_mm512_set_epi16", + zz3085: "_mm512_set_pd", + zz3086: "sys_common", + zz3087: "file_type", + zz3088: "Stdin", + zz3089: "Current", + zz3090: "rhs_ty", + zz3091: "Owner", + zz3092: "SourceFileHashAlgorithm", + zz3093: "ModuleItems", + zz3094: "DropGlue", + zz3095: "pclmulqdq", + zz3096: ".", + zz3097: "DivAssign", + zz3098: "MulAssign", + zz3099: "Cloned", + zz3100: " let s = RandomState::new();", + zz3101: "old_len", + zz3102: "constify_imm4_round", + zz3103: "20.", + zz3104: "strip_attrs_pub", + zz3105: "snapshot", + zz3106: "InlineAsmArch", + zz3107: "CrateItem", + zz3108: "SubDiagnostic", + zz3109: "CodegenCx", + zz3110: " Adds to the current value, returning the previous value.", + zz3111: " [`atomic`] types via the `fetch_add` method by passing", + zz3112: "FlatMap", + zz3113: "Waker", + zz3114: " _MM_FROUND_CUR_DIRECTION // use MXCSR.RC; see _MM_SET_ROUNDING_MODE", + zz3115: "reader", + zz3116: "row", + zz3117: "UnsignedInt", + zz3118: "TryBlock", + zz3119: "visit_trait_item", + zz3120: "ToStableHashKey", + zz3121: "Pos", + zz3122: "DotDotDot", + zz3123: "MIN_POSITIVE", + zz3124: " Calculates the offset from a pointer using wrapping arithmetic.", + zz3125: " This operation itself is always safe, but using the resulting pointer is not.", + zz3126: " The resulting pointer remains attached to the same allocated object that `self` points to.", + zz3127: " It may *not* be used to access a different allocated object. Note that in Rust, every", + zz3128: " (stack-allocated) variable is considered a separate allocated object.", + zz3129: " the same as `y` even if we assume `T` has size `1` and there is no overflow: `z` is still", + zz3130: " attached to the object `x` is attached to, and dereferencing it is Undefined Behavior unless", + zz3131: " `x` and `y` point into the same allocated object.", + zz3132: " can be optimized better and is thus preferable in performance-sensitive code.", + zz3133: " The delayed check only considers the value of the pointer that was dereferenced, not the", + zz3134: " intermediate values used during the computation of the final result. For example,", + zz3135: " If you need to cross object boundaries, cast the pointer to an integer and", + zz3136: " do the arithmetic there.", + zz3137: " let step = 2;", + zz3138: "Filter", + zz3139: "func", + zz3140: "futures do nothing unless you `.await` or poll them", + zz3141: "avx512cd", + zz3142: "Search", + zz3143: " use std::fs::OpenOptions;", + zz3144: "Segment", + zz3145: "Bang", + zz3146: "AArch64", + zz3147: "CodeRegion", + zz3148: "ReStatic", + zz3149: "MirSource", + zz3150: "const_maybe_uninit_assume_init", + zz3151: " Correct usage of this method:", + zz3152: " *Incorrect* usage of this method:", + zz3153: " Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.", + zz3154: "Flatten", + zz3155: "map_err", + zz3156: "xs", + zz3157: "duration", + zz3158: " Internally this type may be viewed as:", + zz3159: " (as well as unsigned versions). Each intrinsic may interpret the", + zz3160: " internal bits differently, check the documentation of the intrinsic", + zz3161: " to see how it's being used.", + zz3162: " to the `avx` and up target features for x86/x86_64.", + zz3163: "visit_impl_item", + zz3164: "WithSuccessors", + zz3165: "Stability", + zz3166: "BindingForm", + zz3167: "AssertMessage", + zz3168: "move_data", + zz3169: "xsaveopt", + zz3170: "RADIX", + zz3171: "MANTISSA_DIGITS", + zz3172: "DIGITS", + zz3173: "EPSILON", + zz3174: "MIN_10_EXP", + zz3175: "MAX_10_EXP", + zz3176: "normalize", + zz3177: " # Invariants", + zz3178: "flat_map", + zz3179: "slice_rsplit", + zz3180: "cast_ptr_alignment", + zz3181: "_mm_setr_epi32", + zz3182: "r10", + zz3183: "r11", + zz3184: " let mut v = vec![0, 1, 2];", + zz3185: "blk", + zz3186: "Typeof", + zz3187: "start_col", + zz3188: "Builtin", + zz3189: "FnPointer", + zz3190: "Nan", + zz3191: "escape_default", + zz3192: "FilterMap", + zz3193: " [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html", + zz3194: "as_i32x4", + zz3195: "_mm_set_epi16", + zz3196: " use std::sync::Once;", + zz3197: "Control", + zz3198: "end_col", + zz3199: "DotDot", + zz3200: "EqPredicate", + zz3201: "nested_visit_map", + zz3202: "RetagKind", + zz3203: "AdtKind", + zz3204: "Infinite", + zz3205: "const_int_methods", + zz3206: " It cannot serve as an [`Iterator`] because it doesn't have a starting point.", + zz3207: " [slicing index]: crate::slice::SliceIndex", + zz3208: "SkipWhile", + zz3209: "TakeWhile", + zz3210: " time), starting at the beginning of the slice.", + zz3211: " the [`remainder`] function from the iterator.", + zz3212: "str_match_indices", + zz3213: "is_prefix_of", + zz3214: "i32x16", + zz3215: "shf", + zz3216: "extend_from_slice", + zz3217: "WaitTimeoutResult", + zz3218: "selection", + zz3219: "Query", + zz3220: "delay_span_bug", + zz3221: "ParseSess", + zz3222: "FmtPrinter", + zz3223: "SwitchTargetsIter", + zz3224: "MapWhile", + zz3225: "Rev", + zz3226: "Scan", + zz3227: " // we can still use `iter`, as there are more elements.", + zz3228: " The iterator yields one value if the [`Option`] is a [`Some`], otherwise none.", + zz3229: "RawWaker", + zz3230: "begin_panic_fmt", + zz3231: "SymbolName", + zz3232: " use std::thread::sleep;", + zz3233: "Demangle", + zz3234: "tables", + zz3235: "FakeReadCause", + zz3236: "wrapping_next_power_of_two", + zz3237: "StepBy", + zz3238: "has_fields", + zz3239: "resume_unwind", + zz3240: "OnceState", + zz3241: "where_clause", + zz3242: "ni", + zz3243: "OffsetOverflowError", + zz3244: "UnstableFeatures", + zz3245: "def_key", + zz3246: " // Iterate using a raw pointer in increments of two elements", + zz3247: " while ptr != end_rounded_up {", + zz3248: "_mm512_set_ps", + zz3249: "_mm512_setr_epi64", + zz3250: " pointers from children back to their parents.", + zz3251: "impl_eq", + zz3252: " map.insert(1, 2);", + zz3253: "Ipv6Addr", + zz3254: "sf", + zz3255: "s3", + zz3256: "hygiene", + zz3257: "RealFileName", + zz3258: "AssocOp", + zz3259: "ByValue", + zz3260: "out_expr", + zz3261: "pre_link_args", + zz3262: "ObjectLifetimeDefault", + zz3263: "TyVid", + zz3264: "NullOp", + zz3265: "Assert", + zz3266: " thread::spawn(move || {", + zz3267: "advance_by", + zz3268: " fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {", + zz3269: "must eventually call `finish()` on Debug builders", + zz3270: "SplitMut", + zz3271: "RChunksExact", + zz3272: "chunks", + zz3273: "split_at", + zz3274: "deallocate", + zz3275: "x0", + zz3276: "r1", + zz3277: "resize", + zz3278: "New", + zz3279: " Representation of a demangled symbol name.", + zz3280: " subfield of the protected data.", + zz3281: " former doesn't support temporarily unlocking and re-locking, since that", + zz3282: " could introduce soundness issues if the locked object is modified by another", + zz3283: " thread.", + zz3284: "r8", + zz3285: "r9", + zz3286: "r12", + zz3287: "r14", + zz3288: "TargetTriple", + zz3289: "var_values", + zz3290: "SourceScopeData", + zz3291: "rposition", + zz3292: "OnceWith", + zz3293: "Sum", + zz3294: "is_sorted_by", + zz3295: " bar: i32,", + zz3296: "ChunksExact", + zz3297: "RChunks", + zz3298: "ArrayChunks", + zz3299: "split_whitespace", + zz3300: " Implementations are encouraged to return `Err` on memory exhaustion rather than panicking or", + zz3301: " aborting, but this is not a strict requirement. (Specifically: it is *legal* to implement", + zz3302: " this trait atop an underlying native allocation library that aborts on memory exhaustion.)", + zz3303: " Clients wishing to abort computation in response to an allocation error are encouraged to", + zz3304: " call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.", + zz3305: " Panics if the new capacity exceeds `isize::MAX` bytes.", + zz3306: "dwControlKeyState", + zz3307: "ret_ty", + zz3308: "ImplTrait", + zz3309: "ReadGuard", + zz3310: "const_int_conversion", + zz3311: "ptr_eq", + zz3312: " let mut map = BTreeMap::new();", + zz3313: "steps_between", + zz3314: " iterator.", + zz3315: "as_deref", + zz3316: "RSplitMut", + zz3317: "next_unchecked", + zz3318: "is_suffix_of", + zz3319: "f32x16", + zz3320: "_mm_set1_epi64x", + zz3321: " abs_all(&mut input);", + zz3322: "Wide", + zz3323: "StackBase", + zz3324: "StackLimit", + zz3325: "dwReserved1", + zz3326: "$crate::alloc::vec", + zz3327: "ensure_sufficient_stack", + zz3328: "ItemLikeVisitor", + zz3329: "abstract_const", + zz3330: "ts", + zz3331: "FromFn", + zz3332: "repeat_with", + zz3333: "RepeatWith", + zz3334: "strip_prefix_of", + zz3335: "strip_suffix_of", + zz3336: "3.0", + zz3337: "0x7FFFFFFF", + zz3338: "Ipv4Addr", + zz3339: "Long", + zz3340: "linker", + zz3341: "$crate::quote", + zz3342: "s4", + zz3343: "predecessors", + zz3344: "resolver", + zz3345: " some other means.", + zz3346: " [`String`]: ../../std/string/struct.String.html", + zz3347: "ChunksMut", + zz3348: "ChunksExactMut", + zz3349: "RChunksExactMut", + zz3350: "RChunksMut", + zz3351: "ArrayChunksMut", + zz3352: "RawWakerVTable", + zz3353: "f64x8", + zz3354: " [`from_utf8`]: String::from_utf8", + zz3355: "CONTEXT", + zz3356: "symbol_index", + zz3357: "term", + zz3358: "ti", + zz3359: "Named", + zz3360: "OwningRef", + zz3361: "MappedReadGuard", + zz3362: "debug_span", + zz3363: "Variants", + zz3364: "Printer", + zz3365: "check_name", + zz3366: "CodegenFnAttrFlags", + zz3367: "UserTypeProjections", + zz3368: "AscribeUserType", + zz3369: "low", + zz3370: "VaList", + zz3371: "pieces", + zz3372: " A struct to help with [`fmt::Debug`](Debug) implementations.", + zz3373: "DoubleEndedSearcher", + zz3374: "map_values_mut", + zz3375: "eprint", + zz3376: "obj", + zz3377: "file_header", + zz3378: "AstPass", + zz3379: "pats", + zz3380: "is_shorthand", + zz3381: "FieldsShape", + zz3382: "icx", + zz3383: "VarBindingForm", + zz3384: "sup", + zz3385: "Repr", + zz3386: "ArrayWindows", + zz3387: "increment", + zz3388: " msg = receiver.recv().unwrap();", + zz3389: "base_address", + zz3390: "Undefined", + zz3391: "Nop", + zz3392: "Rollback", + zz3393: "identify_callsite", + zz3394: " [span ID]: ../span/struct.Id.html", + zz3395: "expect_local", + zz3396: "BinOpEq", + zz3397: "local_id", + zz3398: "SymbolExportLevel", + zz3399: "return_ty", + zz3400: "-", + zz3401: "Rust", + zz3402: " use std::collections::VecDeque;", + zz3403: " Finishes output and returns any error encountered.", + zz3404: "hashmap_internals", + zz3405: "RSplitNMut", + zz3406: "SplitNMut", + zz3407: "CharIndices", + zz3408: "into_future", + zz3409: "tail_len", + zz3410: "tail_start", + zz3411: "available_concurrency", + zz3412: " assert_eq!(socket.port(), 8080);", + zz3413: "optional_header", + zz3414: "section_number", + zz3415: "Direct", + zz3416: "of_trait", + zz3417: "Hexagon", + zz3418: "DefPathData", + zz3419: "EarlyBoundRegion", + zz3420: "SuccessorsMut", + zz3421: "Reveal", + zz3422: "ExistentialPredicate", + zz3423: " let v_clone = v_orig.clone();", + zz3424: " let len = slice.len();", + zz3425: " assert!(mid <= len);", + zz3426: "peek", + zz3427: " struct Foo(Vec);", + zz3428: "x2", + zz3429: "tbm", + zz3430: "5.0", + zz3431: "_mm256_set_epi16", + zz3432: "_mm512_set_epi8", + zz3433: "extracta", + zz3434: " [`TcpStream`]: crate::net::TcpStream", + zz3435: "debug_addr", + zz3436: "unit_length", + zz3437: "pretty", + zz3438: " use rand::prelude::*;", + zz3439: " for _ in 0..100 {", + zz3440: "SsoHashMap", + zz3441: "Unreachable", + zz3442: "adjustment", + zz3443: "Fp", + zz3444: " use std::panic;", + zz3445: "failure", + zz3446: "write_u64", + zz3447: "ParseBoolError", + zz3448: "allocate", + zz3449: "i64x8", + zz3450: "split_off", + zz3451: " assert!(vec.capacity() >= 11);", + zz3452: " let (send, recv) = channel();", + zz3453: "EndOfFile", + zz3454: "major_linker_version", + zz3455: "minor_linker_version", + zz3456: "size_of_code", + zz3457: "size_of_initialized_data", + zz3458: "size_of_uninitialized_data", + zz3459: "address_of_entry_point", + zz3460: "base_of_code", + zz3461: "section_alignment", + zz3462: "serialize", + zz3463: "DiagnosticMessageId", + zz3464: "BlockTailInfo", + zz3465: "FreshTy", + zz3466: " struct Foo;", + zz3467: "forward_checked", + zz3468: "backward_checked", + zz3469: "SplitWhitespace", + zz3470: "EncodeUtf16", + zz3471: "SplitAsciiWhitespace", + zz3472: "i16x8", + zz3473: "forget_node_type", + zz3474: "get_mut_unchecked", + zz3475: "Unsupported", + zz3476: " cause many collisions and very poor performance. Setting it", + zz3477: " manually using this function can expose a DoS attack vector.", + zz3478: " The `hash_builder` passed should implement the [`BuildHasher`] trait for", + zz3479: " the HashMap to be useful, see its documentation for details.", + zz3480: "AllocationSize", + zz3481: "files", + zz3482: "segment_size", + zz3483: "e_flags", + zz3484: "sh_flags", + zz3485: "st_info", + zz3486: "st_other", + zz3487: "ncmds", + zz3488: "n_desc", + zz3489: "Val", + zz3490: "RegionPredicate", + zz3491: "Rptr", + zz3492: "yield_ty", + zz3493: "write_usize", + zz3494: "is_sorted", + zz3495: ",", + zz3496: "split_ascii_whitespace", + zz3497: "waker", + zz3498: "vector", + zz3499: "__self_1_4", + zz3500: "sink", + zz3501: " [IETF RFC 793]: https://tools.ietf.org/html/rfc793", + zz3502: " [`accept`]: TcpListener::accept", + zz3503: "Component", + zz3504: " [dropped]: Drop", + zz3505: "hSourceFile", + zz3506: "hDestinationFile", + zz3507: "RawSocket", + zz3508: "number_of_sections", + zz3509: "number_of_symbols", + zz3510: "class_id", + zz3511: "number_of_linenumbers", + zz3512: "family_id", + zz3513: "image_id", + zz3514: "bases", + zz3515: "unit_header_offset", + zz3516: "Dylib", + zz3517: "Tls", + zz3518: "ilocalsym", + zz3519: "nlocalsym", + zz3520: "iextdefsym", + zz3521: "nextdefsym", + zz3522: "nextrel", + zz3523: " Also includes the string table used for the symbol names.", + zz3524: "__tracing_mk_span", + zz3525: "Primitive", + zz3526: "ArenaCacheSelector", + zz3527: "SourceScopeLocalData", + zz3528: "MiscObligation", + zz3529: "mplace", + zz3530: "atomic_nand", + zz3531: " Calculates the offset from a pointer.", + zz3532: "maybe_uninit_extra", + zz3533: "sort_unstable", + zz3534: "BufReader", + zz3535: "iovec", + zz3536: "new_table", + zz3537: "Dyn", + zz3538: " |", + zz3539: "RootDirectory", + zz3540: "PrivilegeCount", + zz3541: "SecurityDescriptor", + zz3542: "Privileges", + zz3543: "AuthenticationId", + zz3544: "IoReadBytesLimit", + zz3545: "IoWriteBytesLimit", + zz3546: "MaxBandwidth", + zz3547: "AllocationBase", + zz3548: "AllocationProtect", + zz3549: "RegionSize", + zz3550: "TimeCheck", + zz3551: "TargetProcessors", + zz3552: "Processors", + zz3553: "Spare", + zz3554: "Sig1", + zz3555: "Sig2", + zz3556: "NumberOfLinenumbers", + zz3557: "dwOSVersionInfoSize", + zz3558: "dwMajorVersion", + zz3559: "dwMinorVersion", + zz3560: "dwBuildNumber", + zz3561: "dwPlatformId", + zz3562: "szCSDVersion", + zz3563: "ulFlags", + zz3564: "TmIdentity", + zz3565: "pData", + zz3566: "iType", + zz3567: "nVersion", + zz3568: "tmHeight", + zz3569: "tmAscent", + zz3570: "tmDescent", + zz3571: "tmInternalLeading", + zz3572: "tmExternalLeading", + zz3573: "tmAveCharWidth", + zz3574: "tmMaxCharWidth", + zz3575: "tmWeight", + zz3576: "tmOverhang", + zz3577: "tmDigitizedAspectX", + zz3578: "tmDigitizedAspectY", + zz3579: "tmFirstChar", + zz3580: "tmLastChar", + zz3581: "tmDefaultChar", + zz3582: "tmBreakChar", + zz3583: "tmItalic", + zz3584: "tmUnderlined", + zz3585: "tmStruckOut", + zz3586: "tmPitchAndFamily", + zz3587: "tmCharSet", + zz3588: "adapterId", + zz3589: "iMode", + zz3590: "ihPal", + zz3591: "cbRgnData", + zz3592: "RgnData", + zz3593: "is_range_literal", + zz3594: "CompareImplTypeObligation", + zz3595: "ObjectSafe", + zz3596: "method returns a new number and does not mutate the original value", + zz3597: "is_zero", + zz3598: "is_power_of_two", + zz3599: "leak", + zz3600: "or_else", + zz3601: "impl FnMut(T) -> Option", + zz3602: "vars", } } @@ -1446,6 +5051,12 @@ rustc_index::newtype_index! { pub struct SymbolIndex { .. } } +fn fx_hash(string: &str) -> u64 { + let mut hasher = FxHasher::default(); + string.hash(&mut hasher); + hasher.finish() +} + impl Symbol { const fn new(n: u32) -> Self { Symbol(SymbolIndex::from_u32(n)) @@ -1453,7 +5064,14 @@ impl Symbol { /// Maps a string to its interned representation. pub fn intern(string: &str) -> Self { - with_interner(|interner| interner.intern(string)) + let hash = fx_hash(string); + if let Some((_, symbol)) = + unsafe { &STATIC_SYMBOLS }.raw_entry().from_key_hashed_nocheck(hash, string) + { + *symbol + } else { + with_interner(|interner| interner.intern_ext(hash, string)) + } } /// Convert to a `SymbolStr`. This is a slowish operation because it @@ -1534,18 +5152,28 @@ pub struct Interner { strings: Vec<&'static str>, } +use std::hash::BuildHasherDefault; +use std::marker::PhantomData; + +#[allow(unused)] +static mut STATIC_SYMBOLS: FxHashMap<&'static str, Symbol> = + FxHashMap::with_hasher(BuildHasherDefault(PhantomData)); + impl Interner { fn prefill(init: &[&'static str]) -> Self { - Interner { - strings: init.into(), - names: init.iter().copied().zip((0..).map(Symbol::new)).collect(), - ..Default::default() + let names: FxHashMap<_, _> = init.iter().copied().zip((0..).map(Symbol::new)).collect(); + unsafe { + STATIC_SYMBOLS = names.clone(); + // Some memory fence must go here, + // and all accesses to `Symbol::intern` must go after it. } + + Interner { strings: init.into(), names, ..Default::default() } } #[inline] - pub fn intern(&mut self, string: &str) -> Symbol { - if let Some(&name) = self.names.get(string) { + fn intern_ext(&mut self, hash: u64, string: &str) -> Symbol { + if let Some((_, &name)) = self.names.raw_entry().from_key_hashed_nocheck(hash, string) { return name; } @@ -1563,6 +5191,11 @@ impl Interner { name } + #[inline] + pub fn intern(&mut self, string: &str) -> Symbol { + self.intern_ext(fx_hash(string), string) + } + // Get the symbol as a string. `Symbol::as_str()` should be used in // preference to this function. pub fn get(&self, symbol: Symbol) -> &str { diff --git a/library/core/src/hash/mod.rs b/library/core/src/hash/mod.rs index f53ba98143842..592675da8cedf 100644 --- a/library/core/src/hash/mod.rs +++ b/library/core/src/hash/mod.rs @@ -496,7 +496,9 @@ pub trait BuildHasher { /// [`HashSet`]: ../../std/collections/struct.HashSet.html /// [zero-sized]: https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts #[stable(since = "1.7.0", feature = "build_hasher")] -pub struct BuildHasherDefault(marker::PhantomData); +pub struct BuildHasherDefault( + #[stable(since = "1.7.0", feature = "build_hasher")] pub marker::PhantomData, +); #[stable(since = "1.9.0", feature = "core_impl_debug")] impl fmt::Debug for BuildHasherDefault { diff --git a/library/std/src/collections/hash/map.rs b/library/std/src/collections/hash/map.rs index 0680b1fc32975..5c6b7ed4e9c60 100644 --- a/library/std/src/collections/hash/map.rs +++ b/library/std/src/collections/hash/map.rs @@ -263,7 +263,8 @@ impl HashMap { /// ``` #[inline] #[stable(feature = "hashmap_build_hasher", since = "1.7.0")] - pub fn with_hasher(hash_builder: S) -> HashMap { + #[rustc_const_unstable(feature = "zzz", issue = "123456")] + pub const fn with_hasher(hash_builder: S) -> HashMap { HashMap { base: base::HashMap::with_hasher(hash_builder) } } diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs index 4b521985ca1ad..4a90506cc3dcb 100644 --- a/src/tools/tidy/src/deps.rs +++ b/src/tools/tidy/src/deps.rs @@ -132,6 +132,10 @@ const PERMITTED_DEPENDENCIES: &[&str] = &[ "parking_lot", "parking_lot_core", "pathdiff", + "phf", + "phf_codegen", + "phf_generator", + "phf_shared", "pkg-config", "polonius-engine", "ppv-lite86", @@ -164,6 +168,7 @@ const PERMITTED_DEPENDENCIES: &[&str] = &[ "sha-1", "sha2", "smallvec", + "siphasher", "snap", "stable_deref_trait", "stacker",