src/librustc_span/symbol.rs

   1 //! An "interner" is a data structure that associates values with usize tags and
   2 //! allows bidirectional lookup; i.e., given a value, one can easily find the
   3 //! type, and vice versa.
   4
   5 use rustc_arena::DroplessArena;
   6 use rustc_data_structures::fx::FxHashMap;
   7 use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey};
   8 use rustc_macros::{symbols, HashStable_Generic};
   9 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
  10 use rustc_serialize::{UseSpecializedDecodable, UseSpecializedEncodable};
  11
  12 use std::cmp::{Ord, PartialEq, PartialOrd};
  13 use std::fmt;
  14 use std::hash::{Hash, Hasher};
  15 use std::str;
  16
  17 use crate::{Span, DUMMY_SP, SESSION_GLOBALS};
  18
  19 #[cfg(test)]
  20 mod tests;
  21
  22 // The proc macro code for this is in `src/librustc_macros/src/symbols.rs`.
  23 symbols! {
  24     // After modifying this list adjust `is_special`, `is_used_keyword`/`is_unused_keyword`,
  25     // this should be rarely necessary though if the keywords are kept in alphabetic order.
  26     Keywords {
  27         // Special reserved identifiers used internally for elided lifetimes,
  28         // unnamed method parameters, crate root module, error recovery etc.
  29         Invalid:            "",
  30         PathRoot:           "{{root}}",
  31         DollarCrate:        "$crate",
  32         Underscore:         "_",
  33
  34         // Keywords that are used in stable Rust.
  35         As:                 "as",
  36         Break:              "break",
  37         Const:              "const",
  38         Continue:           "continue",
  39         Crate:              "crate",
  40         Else:               "else",
  41         Enum:               "enum",
  42         Extern:             "extern",
  43         False:              "false",
  44         Fn:                 "fn",
  45         For:                "for",
  46         If:                 "if",
  47         Impl:               "impl",
  48         In:                 "in",
  49         Let:                "let",
  50         Loop:               "loop",
  51         Match:              "match",
  52         Mod:                "mod",
  53         Move:               "move",
  54         Mut:                "mut",
  55         Pub:                "pub",
  56         Ref:                "ref",
  57         Return:             "return",
  58         SelfLower:          "self",
  59         SelfUpper:          "Self",
  60         Static:             "static",
  61         Struct:             "struct",
  62         Super:              "super",
  63         Trait:              "trait",
  64         True:               "true",
  65         Type:               "type",
  66         Unsafe:             "unsafe",
  67         Use:                "use",
  68         Where:              "where",
  69         While:              "while",
  70
  71         // Keywords that are used in unstable Rust or reserved for future use.
  72         Abstract:           "abstract",
  73         Become:             "become",
  74         Box:                "box",
  75         Do:                 "do",
  76         Final:              "final",
  77         Macro:              "macro",
  78         Override:           "override",
  79         Priv:               "priv",
  80         Typeof:             "typeof",
  81         Unsized:            "unsized",
  82         Virtual:            "virtual",
  83         Yield:              "yield",
  84
  85         // Edition-specific keywords that are used in stable Rust.
  86         Async:              "async", // >= 2018 Edition only
  87         Await:              "await", // >= 2018 Edition only
  88         Dyn:                "dyn", // >= 2018 Edition only
  89
  90         // Edition-specific keywords that are used in unstable Rust or reserved for future use.
  91         Try:                "try", // >= 2018 Edition only
  92
  93         // Special lifetime names
  94         UnderscoreLifetime: "'_",
  95         StaticLifetime:     "'static",
  96
  97         // Weak keywords, have special meaning only in specific contexts.
  98         Auto:               "auto",
  99         Catch:              "catch",
 100         Default:            "default",
 101         MacroRules:         "macro_rules",
 102         Raw:                "raw",
 103         Union:              "union",
 104     }
 105
 106     // Pre-interned symbols that can be referred to with `rustc_span::sym::*`.
 107     //
 108     // The symbol is the stringified identifier unless otherwise specified, in
 109     // which case the name should mention the non-identifier punctuation.
 110     // E.g. `sym::proc_dash_macro` represents "proc-macro", and it shouldn't be
 111     // called `sym::proc_macro` because then it's easy to mistakenly think it
 112     // represents "proc_macro".
 113     //
 114     // As well as the symbols listed, there are symbols for the the strings
 115     // "0", "1", ..., "9", which are accessible via `sym::integer`.
 116     //
 117     // The proc macro will abort if symbols are not in alphabetical order (as
 118     // defined by `impl Ord for str`) or if any symbols are duplicated. Vim
 119     // users can sort the list by selecting it and executing the command
 120     // `:'<,'>!LC_ALL=C sort`.
 121     //
 122     // There is currently no checking that all symbols are used; that would be
 123     // nice to have.
 124     Symbols {
 125         Arc,
 126         ArgumentV1,
 127         Arguments,
 128         C,
 129         Clone,
 130         Copy,
 131         Debug,
 132         Decodable,
 133         Default,
 134         Encodable,
 135         Eq,
 136         Equal,
 137         Err,
 138         From,
 139         Future,
 140         FxHashMap,
 141         FxHashSet,
 142         GlobalAlloc,
 143         Hash,
 144         HashMap,
 145         HashSet,
 146         Input,
 147         IntoIterator,
 148         ItemContext,
 149         Iterator,
 150         Layout,
 151         LintPass,
 152         None,
 153         Ok,
 154         Option,
 155         Ord,
 156         Ordering,
 157         Output,
 158         PartialEq,
 159         PartialOrd,
 160         Pending,
 161         Pin,
 162         Poll,
 163         ProcMacroHack,
 164         ProceduralMasqueradeDummyType,
 165         Range,
 166         RangeFrom,
 167         RangeFull,
 168         RangeInclusive,
 169         RangeTo,
 170         RangeToInclusive,
 171         Rc,
 172         Ready,
 173         Result,
 174         Return,
 175         RustcDecodable,
 176         RustcEncodable,
 177         Send,
 178         Some,
 179         Sync,
 180         Target,
 181         Try,
 182         Ty,
 183         TyCtxt,
 184         TyKind,
 185         Vec,
 186         Yield,
 187         _Self,
 188         __next,
 189         _task_context,
 190         aarch64_target_feature,
 191         abi,
 192         abi_amdgpu_kernel,
 193         abi_avr_interrupt,
 194         abi_efiapi,
 195         abi_msp430_interrupt,
 196         abi_ptx,
 197         abi_sysv64,
 198         abi_thiscall,
 199         abi_unadjusted,
 200         abi_vectorcall,
 201         abi_x86_interrupt,
 202         abort,
 203         aborts,
 204         add,
 205         add_assign,
 206         add_with_overflow,
 207         address,
 208         advanced_slice_patterns,
 209         adx_target_feature,
 210         alias,
 211         align,
 212         align_offset,
 213         alignstack,
 214         all,
 215         alloc,
 216         alloc_error_handler,
 217         alloc_layout,
 218         alloc_zeroed,
 219         allocator,
 220         allocator_internals,
 221         allow,
 222         allow_fail,
 223         allow_internal_unsafe,
 224         allow_internal_unstable,
 225         allow_internal_unstable_backcompat_hack,
 226         allowed,
 227         always,
 228         and,
 229         any,
 230         arbitrary_enum_discriminant,
 231         arbitrary_self_types,
 232         arith_offset,
 233         arm_target_feature,
 234         array,
 235         as_str,
 236         asm,
 237         assert,
 238         assert_inhabited,
 239         assert_receiver_is_total_eq,
 240         assert_uninit_valid,
 241         assert_zero_valid,
 242         associated_consts,
 243         associated_type_bounds,
 244         associated_type_defaults,
 245         associated_types,
 246         assume,
 247         assume_init,
 248         async_await,
 249         async_closure,
 250         atomics,
 251         att_syntax,
 252         attr,
 253         attr_literals,
 254         attributes,
 255         augmented_assignments,
 256         automatically_derived,
 257         avx512_target_feature,
 258         await_macro,
 259         begin_panic,
 260         bench,
 261         bin,
 262         bind_by_move_pattern_guards,
 263         bindings_after_at,
 264         bitand,
 265         bitand_assign,
 266         bitor,
 267         bitor_assign,
 268         bitreverse,
 269         bitxor,
 270         bitxor_assign,
 271         block,
 272         bool,
 273         borrowck_graphviz_format,
 274         borrowck_graphviz_postflow,
 275         borrowck_graphviz_preflow,
 276         box_free,
 277         box_patterns,
 278         box_syntax,
 279         braced_empty_structs,
 280         breakpoint,
 281         bswap,
 282         c_variadic,
 283         call,
 284         call_mut,
 285         call_once,
 286         caller_location,
 287         cdylib,
 288         ceilf32,
 289         ceilf64,
 290         cfg,
 291         cfg_accessible,
 292         cfg_attr,
 293         cfg_attr_multi,
 294         cfg_doctest,
 295         cfg_sanitize,
 296         cfg_target_feature,
 297         cfg_target_has_atomic,
 298         cfg_target_thread_local,
 299         cfg_target_vendor,
 300         cfg_version,
 301         char,
 302         clippy,
 303         clone,
 304         clone_closures,
 305         clone_from,
 306         closure_to_fn_coercion,
 307         cmp,
 308         cmpxchg16b_target_feature,
 309         coerce_unsized,
 310         cold,
 311         column,
 312         compile_error,
 313         compiler_builtins,
 314         concat,
 315         concat_idents,
 316         conservative_impl_trait,
 317         console,
 318         const_compare_raw_pointers,
 319         const_constructor,
 320         const_eval_limit,
 321         const_extern_fn,
 322         const_fn,
 323         const_fn_transmute,
 324         const_fn_union,
 325         const_generics,
 326         const_if_match,
 327         const_in_array_repeat_expressions,
 328         const_indexing,
 329         const_let,
 330         const_loop,
 331         const_mut_refs,
 332         const_panic,
 333         const_precise_live_drops,
 334         const_ptr,
 335         const_raw_ptr_deref,
 336         const_raw_ptr_to_usize_cast,
 337         const_slice_ptr,
 338         const_trait_bound_opt_out,
 339         const_trait_impl,
 340         const_transmute,
 341         contents,
 342         context,
 343         convert,
 344         copy,
 345         copy_closures,
 346         copy_nonoverlapping,
 347         copysignf32,
 348         copysignf64,
 349         core,
 350         core_intrinsics,
 351         cosf32,
 352         cosf64,
 353         count_code_region,
 354         coverage_counter_add,
 355         coverage_counter_subtract,
 356         coverage_unreachable,
 357         crate_id,
 358         crate_in_paths,
 359         crate_local,
 360         crate_name,
 361         crate_type,
 362         crate_visibility_modifier,
 363         crt_dash_static: "crt-static",
 364         ctlz,
 365         ctlz_nonzero,
 366         ctpop,
 367         cttz,
 368         cttz_nonzero,
 369         custom_attribute,
 370         custom_derive,
 371         custom_inner_attributes,
 372         custom_test_frameworks,
 373         dead_code,
 374         dealloc,
 375         debug,
 376         debug_assertions,
 377         debug_trait,
 378         decl_macro,
 379         declare_lint_pass,
 380         decode,
 381         default_lib_allocator,
 382         default_type_parameter_fallback,
 383         default_type_params,
 384         delay_span_bug_from_inside_query,
 385         deny,
 386         deprecated,
 387         deref,
 388         deref_mut,
 389         derive,
 390         diagnostic,
 391         direct,
 392         discriminant_kind,
 393         discriminant_type,
 394         discriminant_value,
 395         dispatch_from_dyn,
 396         div,
 397         div_assign,
 398         doc,
 399         doc_alias,
 400         doc_cfg,
 401         doc_keyword,
 402         doc_masked,
 403         doc_spotlight,
 404         doctest,
 405         document_private_items,
 406         dotdot_in_tuple_patterns,
 407         dotdoteq_in_patterns,
 408         double_braced_closure: "{{closure}}",
 409         double_braced_constant: "{{constant}}",
 410         double_braced_constructor: "{{constructor}}",
 411         double_braced_crate: "{{crate}}",
 412         double_braced_impl: "{{impl}}",
 413         double_braced_misc: "{{misc}}",
 414         double_braced_opaque: "{{opaque}}",
 415         drop,
 416         drop_in_place,
 417         drop_types_in_const,
 418         dropck_eyepatch,
 419         dropck_parametricity,
 420         dylib,
 421         dyn_trait,
 422         eh_catch_typeinfo,
 423         eh_personality,
 424         enable,
 425         enclosing_scope,
 426         encode,
 427         env,
 428         eq,
 429         err,
 430         exact_div,
 431         except,
 432         exchange_malloc,
 433         exclusive_range_pattern,
 434         exhaustive_integer_patterns,
 435         exhaustive_patterns,
 436         existential_type,
 437         exp2f32,
 438         exp2f64,
 439         expected,
 440         expf32,
 441         expf64,
 442         export_name,
 443         expr,
 444         extern_absolute_paths,
 445         extern_crate_item_prelude,
 446         extern_crate_self,
 447         extern_in_paths,
 448         extern_prelude,
 449         extern_types,
 450         external_doc,
 451         f16c_target_feature,
 452         f32,
 453         f32_runtime,
 454         f64,
 455         f64_runtime,
 456         fabsf32,
 457         fabsf64,
 458         fadd_fast,
 459         fdiv_fast,
 460         feature,
 461         ffi_const,
 462         ffi_pure,
 463         ffi_returns_twice,
 464         field,
 465         field_init_shorthand,
 466         file,
 467         float_to_int_unchecked,
 468         floorf32,
 469         floorf64,
 470         fmaf32,
 471         fmaf64,
 472         fmt,
 473         fmt_internals,
 474         fmul_fast,
 475         fn_must_use,
 476         fn_mut,
 477         fn_once,
 478         fn_once_output,
 479         forbid,
 480         forget,
 481         format_args,
 482         format_args_capture,
 483         format_args_nl,
 484         freeze,
 485         frem_fast,
 486         from,
 487         from_desugaring,
 488         from_error,
 489         from_generator,
 490         from_method,
 491         from_ok,
 492         from_size_align_unchecked,
 493         from_trait,
 494         from_usize,
 495         fsub_fast,
 496         fundamental,
 497         future,
 498         future_trait,
 499         ge,
 500         gen_future,
 501         gen_kill,
 502         generator,
 503         generator_state,
 504         generators,
 505         generic_associated_types,
 506         generic_param_attrs,
 507         get_context,
 508         global_allocator,
 509         global_asm,
 510         globs,
 511         gt,
 512         half_open_range_patterns,
 513         hash,
 514         hexagon_target_feature,
 515         hidden,
 516         homogeneous_aggregate,
 517         html_favicon_url,
 518         html_logo_url,
 519         html_no_source,
 520         html_playground_url,
 521         html_root_url,
 522         i128,
 523         i128_type,
 524         i16,
 525         i32,
 526         i64,
 527         i8,
 528         ident,
 529         if_let,
 530         if_while_or_patterns,
 531         ignore,
 532         impl_header_lifetime_elision,
 533         impl_lint_pass,
 534         impl_trait_in_bindings,
 535         import_shadowing,
 536         in_band_lifetimes,
 537         include,
 538         include_bytes,
 539         include_str,
 540         inclusive_range_syntax,
 541         index,
 542         index_mut,
 543         infer_outlives_requirements,
 544         infer_static_outlives_requirements,
 545         inlateout,
 546         inline,
 547         inout,
 548         intel,
 549         into_iter,
 550         into_result,
 551         intrinsics,
 552         irrefutable_let_patterns,
 553         isize,
 554         issue,
 555         issue_5723_bootstrap,
 556         issue_tracker_base_url,
 557         item,
 558         item_like_imports,
 559         iter,
 560         keyword,
 561         kind,
 562         label,
 563         label_break_value,
 564         lang,
 565         lang_items,
 566         lateout,
 567         lazy_normalization_consts,
 568         le,
 569         let_chains,
 570         lhs,
 571         lib,
 572         libc,
 573         lifetime,
 574         likely,
 575         line,
 576         link,
 577         link_args,
 578         link_cfg,
 579         link_llvm_intrinsics,
 580         link_name,
 581         link_ordinal,
 582         link_section,
 583         linkage,
 584         lint_reasons,
 585         literal,
 586         llvm_asm,
 587         local_inner_macros,
 588         log10f32,
 589         log10f64,
 590         log2f32,
 591         log2f64,
 592         log_syntax,
 593         logf32,
 594         logf64,
 595         loop_break_value,
 596         lt,
 597         macro_at_most_once_rep,
 598         macro_escape,
 599         macro_export,
 600         macro_lifetime_matcher,
 601         macro_literal_matcher,
 602         macro_reexport,
 603         macro_use,
 604         macro_vis_matcher,
 605         macros_in_extern,
 606         main,
 607         managed_boxes,
 608         manually_drop,
 609         marker,
 610         marker_trait_attr,
 611         masked,
 612         match_beginning_vert,
 613         match_default_bindings,
 614         maxnumf32,
 615         maxnumf64,
 616         may_dangle,
 617         maybe_uninit,
 618         maybe_uninit_uninit,
 619         maybe_uninit_zeroed,
 620         mem_uninitialized,
 621         mem_zeroed,
 622         member_constraints,
 623         memory,
 624         message,
 625         meta,
 626         min_align_of,
 627         min_align_of_val,
 628         min_const_fn,
 629         min_const_unsafe_fn,
 630         min_specialization,
 631         minnumf32,
 632         minnumf64,
 633         mips_target_feature,
 634         miri_start_panic,
 635         mmx_target_feature,
 636         module,
 637         module_path,
 638         more_struct_aliases,
 639         movbe_target_feature,
 640         move_ref_pattern,
 641         move_val_init,
 642         mul,
 643         mul_assign,
 644         mul_with_overflow,
 645         must_use,
 646         mut_ptr,
 647         mut_slice_ptr,
 648         naked,
 649         naked_functions,
 650         name,
 651         ne,
 652         nearbyintf32,
 653         nearbyintf64,
 654         needs_allocator,
 655         needs_drop,
 656         needs_panic_runtime,
 657         neg,
 658         negate_unsigned,
 659         negative_impls,
 660         never,
 661         never_type,
 662         never_type_fallback,
 663         new,
 664         next,
 665         nll,
 666         no,
 667         no_builtins,
 668         no_core,
 669         no_crate_inject,
 670         no_debug,
 671         no_default_passes,
 672         no_implicit_prelude,
 673         no_inline,
 674         no_link,
 675         no_main,
 676         no_mangle,
 677         no_niche,
 678         no_sanitize,
 679         no_stack_check,
 680         no_start,
 681         no_std,
 682         nomem,
 683         non_ascii_idents,
 684         non_exhaustive,
 685         non_modrs_mods,
 686         none_error,
 687         nontemporal_store,
 688         nontrapping_dash_fptoint: "nontrapping-fptoint",
 689         noreturn,
 690         nostack,
 691         not,
 692         note,
 693         object_safe_for_dispatch,
 694         offset,
 695         omit_gdb_pretty_printer_section,
 696         on,
 697         on_unimplemented,
 698         oom,
 699         opaque,
 700         ops,
 701         opt_out_copy,
 702         optimize,
 703         optimize_attribute,
 704         optin_builtin_traits,
 705         option,
 706         option_env,
 707         option_type,
 708         options,
 709         or,
 710         or_patterns,
 711         out,
 712         overlapping_marker_traits,
 713         owned_box,
 714         packed,
 715         panic,
 716         panic_abort,
 717         panic_bounds_check,
 718         panic_handler,
 719         panic_impl,
 720         panic_implementation,
 721         panic_info,
 722         panic_location,
 723         panic_runtime,
 724         panic_unwind,
 725         param_attrs,
 726         parent_trait,
 727         partial_cmp,
 728         partial_ord,
 729         passes,
 730         pat,
 731         path,
 732         pattern_parentheses,
 733         phantom_data,
 734         pin,
 735         pinned,
 736         platform_intrinsics,
 737         plugin,
 738         plugin_registrar,
 739         plugins,
 740         pointer,
 741         poll,
 742         post_dash_lto: "post-lto",
 743         powerpc_target_feature,
 744         powf32,
 745         powf64,
 746         powif32,
 747         powif64,
 748         pre_dash_lto: "pre-lto",
 749         precise_pointer_size_matching,
 750         pref_align_of,
 751         prefetch_read_data,
 752         prefetch_read_instruction,
 753         prefetch_write_data,
 754         prefetch_write_instruction,
 755         prelude,
 756         prelude_import,
 757         preserves_flags,
 758         primitive,
 759         proc_dash_macro: "proc-macro",
 760         proc_macro,
 761         proc_macro_attribute,
 762         proc_macro_def_site,
 763         proc_macro_derive,
 764         proc_macro_expr,
 765         proc_macro_gen,
 766         proc_macro_hygiene,
 767         proc_macro_internals,
 768         proc_macro_mod,
 769         proc_macro_non_items,
 770         proc_macro_path_invoc,
 771         profiler_builtins,
 772         profiler_runtime,
 773         ptr_guaranteed_eq,
 774         ptr_guaranteed_ne,
 775         ptr_offset_from,
 776         pub_restricted,
 777         pure,
 778         pushpop_unsafe,
 779         quad_precision_float,
 780         question_mark,
 781         quote,
 782         raw_dylib,
 783         raw_identifiers,
 784         raw_ref_op,
 785         re_rebalance_coherence,
 786         readonly,
 787         realloc,
 788         reason,
 789         receiver,
 790         recursion_limit,
 791         reexport_test_harness_main,
 792         reference,
 793         reflect,
 794         register_attr,
 795         register_tool,
 796         relaxed_adts,
 797         rem,
 798         rem_assign,
 799         repr,
 800         repr128,
 801         repr_align,
 802         repr_align_enum,
 803         repr_no_niche,
 804         repr_packed,
 805         repr_simd,
 806         repr_transparent,
 807         result,
 808         result_type,
 809         rhs,
 810         rintf32,
 811         rintf64,
 812         riscv_target_feature,
 813         rlib,
 814         rotate_left,
 815         rotate_right,
 816         roundf32,
 817         roundf64,
 818         rt,
 819         rtm_target_feature,
 820         rust,
 821         rust_2015_preview,
 822         rust_2018_preview,
 823         rust_begin_unwind,
 824         rust_eh_personality,
 825         rust_eh_register_frames,
 826         rust_eh_unregister_frames,
 827         rust_oom,
 828         rustc,
 829         rustc_allocator,
 830         rustc_allocator_nounwind,
 831         rustc_allow_const_fn_ptr,
 832         rustc_args_required_const,
 833         rustc_attrs,
 834         rustc_builtin_macro,
 835         rustc_clean,
 836         rustc_const_stable,
 837         rustc_const_unstable,
 838         rustc_conversion_suggestion,
 839         rustc_def_path,
 840         rustc_deprecated,
 841         rustc_diagnostic_item,
 842         rustc_diagnostic_macros,
 843         rustc_dirty,
 844         rustc_dummy,
 845         rustc_dump_env_program_clauses,
 846         rustc_dump_program_clauses,
 847         rustc_dump_user_substs,
 848         rustc_error,
 849         rustc_expected_cgu_reuse,
 850         rustc_if_this_changed,
 851         rustc_inherit_overflow_checks,
 852         rustc_layout,
 853         rustc_layout_scalar_valid_range_end,
 854         rustc_layout_scalar_valid_range_start,
 855         rustc_macro_transparency,
 856         rustc_mir,
 857         rustc_nonnull_optimization_guaranteed,
 858         rustc_object_lifetime_default,
 859         rustc_on_unimplemented,
 860         rustc_outlives,
 861         rustc_paren_sugar,
 862         rustc_partition_codegened,
 863         rustc_partition_reused,
 864         rustc_peek,
 865         rustc_peek_definite_init,
 866         rustc_peek_indirectly_mutable,
 867         rustc_peek_liveness,
 868         rustc_peek_maybe_init,
 869         rustc_peek_maybe_uninit,
 870         rustc_private,
 871         rustc_proc_macro_decls,
 872         rustc_promotable,
 873         rustc_regions,
 874         rustc_reservation_impl,
 875         rustc_specialization_trait,
 876         rustc_stable,
 877         rustc_std_internal_symbol,
 878         rustc_symbol_name,
 879         rustc_synthetic,
 880         rustc_test_marker,
 881         rustc_then_this_would_need,
 882         rustc_unsafe_specialization_marker,
 883         rustc_variance,
 884         rustfmt,
 885         rvalue_static_promotion,
 886         sanitize,
 887         sanitizer_runtime,
 888         saturating_add,
 889         saturating_sub,
 890         self_in_typedefs,
 891         self_struct_ctor,
 892         semitransparent,
 893         send_trait,
 894         shl,
 895         shl_assign,
 896         should_panic,
 897         shr,
 898         shr_assign,
 899         simd,
 900         simd_add,
 901         simd_and,
 902         simd_bitmask,
 903         simd_cast,
 904         simd_ceil,
 905         simd_div,
 906         simd_eq,
 907         simd_extract,
 908         simd_fabs,
 909         simd_fcos,
 910         simd_fexp,
 911         simd_fexp2,
 912         simd_ffi,
 913         simd_flog,
 914         simd_flog10,
 915         simd_flog2,
 916         simd_floor,
 917         simd_fma,
 918         simd_fmax,
 919         simd_fmin,
 920         simd_fpow,
 921         simd_fpowi,
 922         simd_fsin,
 923         simd_fsqrt,
 924         simd_gather,
 925         simd_ge,
 926         simd_gt,
 927         simd_insert,
 928         simd_le,
 929         simd_lt,
 930         simd_mul,
 931         simd_ne,
 932         simd_or,
 933         simd_reduce_add_ordered,
 934         simd_reduce_add_unordered,
 935         simd_reduce_all,
 936         simd_reduce_and,
 937         simd_reduce_any,
 938         simd_reduce_max,
 939         simd_reduce_max_nanless,
 940         simd_reduce_min,
 941         simd_reduce_min_nanless,
 942         simd_reduce_mul_ordered,
 943         simd_reduce_mul_unordered,
 944         simd_reduce_or,
 945         simd_reduce_xor,
 946         simd_rem,
 947         simd_saturating_add,
 948         simd_saturating_sub,
 949         simd_scatter,
 950         simd_select,
 951         simd_select_bitmask,
 952         simd_shl,
 953         simd_shr,
 954         simd_sub,
 955         simd_xor,
 956         since,
 957         sinf32,
 958         sinf64,
 959         size,
 960         size_of,
 961         size_of_val,
 962         sized,
 963         slice,
 964         slice_alloc,
 965         slice_patterns,
 966         slice_u8,
 967         slice_u8_alloc,
 968         slicing_syntax,
 969         soft,
 970         specialization,
 971         speed,
 972         spotlight,
 973         sqrtf32,
 974         sqrtf64,
 975         sse4a_target_feature,
 976         stable,
 977         staged_api,
 978         start,
 979         static_in_const,
 980         static_nobundle,
 981         static_recursion,
 982         staticlib,
 983         std,
 984         std_inject,
 985         stmt,
 986         stmt_expr_attributes,
 987         stop_after_dataflow,
 988         str,
 989         str_alloc,
 990         stringify,
 991         struct_field_attributes,
 992         struct_inherit,
 993         struct_variant,
 994         structural_match,
 995         structural_peq,
 996         structural_teq,
 997         sty,
 998         sub,
 999         sub_assign,
1000         sub_with_overflow,
1001         suggestion,
1002         sym,
1003         sync,
1004         sync_trait,
1005         target_arch,
1006         target_endian,
1007         target_env,
1008         target_family,
1009         target_feature,
1010         target_feature_11,
1011         target_has_atomic,
1012         target_has_atomic_load_store,
1013         target_os,
1014         target_pointer_width,
1015         target_target_vendor,
1016         target_thread_local,
1017         target_vendor,
1018         task,
1019         tbm_target_feature,
1020         termination,
1021         termination_trait,
1022         termination_trait_test,
1023         test,
1024         test_2018_feature,
1025         test_accepted_feature,
1026         test_case,
1027         test_removed_feature,
1028         test_runner,
1029         then_with,
1030         thread,
1031         thread_local,
1032         tool_attributes,
1033         tool_lints,
1034         trace_macros,
1035         track_caller,
1036         trait_alias,
1037         transmute,
1038         transparent,
1039         transparent_enums,
1040         transparent_unions,
1041         trivial_bounds,
1042         truncf32,
1043         truncf64,
1044         try_blocks,
1045         try_trait,
1046         tt,
1047         tuple,
1048         tuple_indexing,
1049         two_phase,
1050         ty,
1051         type_alias_enum_variants,
1052         type_alias_impl_trait,
1053         type_ascription,
1054         type_id,
1055         type_length_limit,
1056         type_macros,
1057         type_name,
1058         u128,
1059         u16,
1060         u32,
1061         u64,
1062         u8,
1063         unaligned_volatile_load,
1064         unaligned_volatile_store,
1065         unboxed_closures,
1066         unchecked_add,
1067         unchecked_div,
1068         unchecked_mul,
1069         unchecked_rem,
1070         unchecked_shl,
1071         unchecked_shr,
1072         unchecked_sub,
1073         underscore_const_names,
1074         underscore_imports,
1075         underscore_lifetimes,
1076         uniform_paths,
1077         unit,
1078         universal_impl_trait,
1079         unix,
1080         unlikely,
1081         unmarked_api,
1082         unpin,
1083         unreachable,
1084         unreachable_code,
1085         unrestricted_attribute_tokens,
1086         unsafe_block_in_unsafe_fn,
1087         unsafe_cell,
1088         unsafe_no_drop_flag,
1089         unsize,
1090         unsized_locals,
1091         unsized_tuple_coercion,
1092         unstable,
1093         untagged_unions,
1094         unused_qualifications,
1095         unwind,
1096         unwind_attributes,
1097         unwrap_or,
1098         use_extern_macros,
1099         use_nested_groups,
1100         used,
1101         usize,
1102         v1,
1103         va_arg,
1104         va_copy,
1105         va_end,
1106         va_list,
1107         va_start,
1108         val,
1109         var,
1110         variant_count,
1111         vec,
1112         vec_type,
1113         version,
1114         vis,
1115         visible_private_types,
1116         volatile,
1117         volatile_copy_memory,
1118         volatile_copy_nonoverlapping_memory,
1119         volatile_load,
1120         volatile_set_memory,
1121         volatile_store,
1122         warn,
1123         wasm_import_module,
1124         wasm_target_feature,
1125         while_let,
1126         windows,
1127         windows_subsystem,
1128         wrapping_add,
1129         wrapping_mul,
1130         wrapping_sub,
1131         write_bytes,
1132     }
1133 }
1134
1135 #[derive(Copy, Clone, Eq, HashStable_Generic)]
1136 pub struct Ident {
1137     pub name: Symbol,
1138     pub span: Span,
1139 }
1140
1141 impl Ident {
1142     #[inline]
1143     /// Constructs a new identifier from a symbol and a span.
1144     pub const fn new(name: Symbol, span: Span) -> Ident {
1145         Ident { name, span }
1146     }
1147
1148     /// Constructs a new identifier with a dummy span.
1149     #[inline]
1150     pub const fn with_dummy_span(name: Symbol) -> Ident {
1151         Ident::new(name, DUMMY_SP)
1152     }
1153
1154     #[inline]
1155     pub fn invalid() -> Ident {
1156         Ident::with_dummy_span(kw::Invalid)
1157     }
1158
1159     /// Maps a string to an identifier with a dummy span.
1160     pub fn from_str(string: &str) -> Ident {
1161         Ident::with_dummy_span(Symbol::intern(string))
1162     }
1163
1164     /// Maps a string and a span to an identifier.
1165     pub fn from_str_and_span(string: &str, span: Span) -> Ident {
1166         Ident::new(Symbol::intern(string), span)
1167     }
1168
1169     /// Replaces `lo` and `hi` with those from `span`, but keep hygiene context.
1170     pub fn with_span_pos(self, span: Span) -> Ident {
1171         Ident::new(self.name, span.with_ctxt(self.span.ctxt()))
1172     }
1173
1174     pub fn without_first_quote(self) -> Ident {
1175         Ident::new(Symbol::intern(self.as_str().trim_start_matches('\'')), self.span)
1176     }
1177
1178     /// "Normalize" ident for use in comparisons using "item hygiene".
1179     /// Identifiers with same string value become same if they came from the same macro 2.0 macro
1180     /// (e.g., `macro` item, but not `macro_rules` item) and stay different if they came from
1181     /// different macro 2.0 macros.
1182     /// Technically, this operation strips all non-opaque marks from ident's syntactic context.
1183     pub fn normalize_to_macros_2_0(self) -> Ident {
1184         Ident::new(self.name, self.span.normalize_to_macros_2_0())
1185     }
1186
1187     /// "Normalize" ident for use in comparisons using "local variable hygiene".
1188     /// Identifiers with same string value become same if they came from the same non-transparent
1189     /// macro (e.g., `macro` or `macro_rules!` items) and stay different if they came from different
1190     /// non-transparent macros.
1191     /// Technically, this operation strips all transparent marks from ident's syntactic context.
1192     pub fn normalize_to_macro_rules(self) -> Ident {
1193         Ident::new(self.name, self.span.normalize_to_macro_rules())
1194     }
1195
1196     /// Convert the name to a `SymbolStr`. This is a slowish operation because
1197     /// it requires locking the symbol interner.
1198     pub fn as_str(self) -> SymbolStr {
1199         self.name.as_str()
1200     }
1201 }
1202
1203 impl PartialEq for Ident {
1204     fn eq(&self, rhs: &Self) -> bool {
1205         self.name == rhs.name && self.span.ctxt() == rhs.span.ctxt()
1206     }
1207 }
1208
1209 impl Hash for Ident {
1210     fn hash<H: Hasher>(&self, state: &mut H) {
1211         self.name.hash(state);
1212         self.span.ctxt().hash(state);
1213     }
1214 }
1215
1216 impl fmt::Debug for Ident {
1217     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1218         fmt::Display::fmt(self, f)?;
1219         fmt::Debug::fmt(&self.span.ctxt(), f)
1220     }
1221 }
1222
1223 /// This implementation is supposed to be used in error messages, so it's expected to be identical
1224 /// to printing the original identifier token written in source code (`token_to_string`),
1225 /// except that AST identifiers don't keep the rawness flag, so we have to guess it.
1226 impl fmt::Display for Ident {
1227     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1228         fmt::Display::fmt(&IdentPrinter::new(self.name, self.is_raw_guess(), None), f)
1229     }
1230 }
1231
1232 impl UseSpecializedEncodable for Ident {
1233     fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
1234         s.emit_struct("Ident", 2, |s| {
1235             s.emit_struct_field("name", 0, |s| self.name.encode(s))?;
1236             s.emit_struct_field("span", 1, |s| self.span.encode(s))
1237         })
1238     }
1239 }
1240
1241 impl UseSpecializedDecodable for Ident {
1242     fn default_decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error> {
1243         d.read_struct("Ident", 2, |d| {
1244             Ok(Ident {
1245                 name: d.read_struct_field("name", 0, Decodable::decode)?,
1246                 span: d.read_struct_field("span", 1, Decodable::decode)?,
1247             })
1248         })
1249     }
1250 }
1251
1252 /// This is the most general way to print identifiers.
1253 /// AST pretty-printer is used as a fallback for turning AST structures into token streams for
1254 /// proc macros. Additionally, proc macros may stringify their input and expect it survive the
1255 /// stringification (especially true for proc macro derives written between Rust 1.15 and 1.30).
1256 /// So we need to somehow pretty-print `$crate` in a way preserving at least some of its
1257 /// hygiene data, most importantly name of the crate it refers to.
1258 /// As a result we print `$crate` as `crate` if it refers to the local crate
1259 /// and as `::other_crate_name` if it refers to some other crate.
1260 /// Note, that this is only done if the ident token is printed from inside of AST pretty-pringing,
1261 /// but not otherwise. Pretty-printing is the only way for proc macros to discover token contents,
1262 /// so we should not perform this lossy conversion if the top level call to the pretty-printer was
1263 /// done for a token stream or a single token.
1264 pub struct IdentPrinter {
1265     symbol: Symbol,
1266     is_raw: bool,
1267     /// Span used for retrieving the crate name to which `$crate` refers to,
1268     /// if this field is `None` then the `$crate` conversion doesn't happen.
1269     convert_dollar_crate: Option<Span>,
1270 }
1271
1272 impl IdentPrinter {
1273     /// The most general `IdentPrinter` constructor. Do not use this.
1274     pub fn new(symbol: Symbol, is_raw: bool, convert_dollar_crate: Option<Span>) -> IdentPrinter {
1275         IdentPrinter { symbol, is_raw, convert_dollar_crate }
1276     }
1277
1278     /// This implementation is supposed to be used when printing identifiers
1279     /// as a part of pretty-printing for larger AST pieces.
1280     /// Do not use this either.
1281     pub fn for_ast_ident(ident: Ident, is_raw: bool) -> IdentPrinter {
1282         IdentPrinter::new(ident.name, is_raw, Some(ident.span))
1283     }
1284 }
1285
1286 impl fmt::Display for IdentPrinter {
1287     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1288         if self.is_raw {
1289             f.write_str("r#")?;
1290         } else {
1291             if self.symbol == kw::DollarCrate {
1292                 if let Some(span) = self.convert_dollar_crate {
1293                     let converted = span.ctxt().dollar_crate_name();
1294                     if !converted.is_path_segment_keyword() {
1295                         f.write_str("::")?;
1296                     }
1297                     return fmt::Display::fmt(&converted, f);
1298                 }
1299             }
1300         }
1301         fmt::Display::fmt(&self.symbol, f)
1302     }
1303 }
1304
1305 /// An newtype around `Ident` that calls [Ident::normalize_to_macro_rules] on
1306 /// construction.
1307 // FIXME(matthewj, petrochenkov) Use this more often, add a similar
1308 // `ModernIdent` struct and use that as well.
1309 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
1310 pub struct MacroRulesNormalizedIdent(Ident);
1311
1312 impl MacroRulesNormalizedIdent {
1313     pub fn new(ident: Ident) -> Self {
1314         Self(ident.normalize_to_macro_rules())
1315     }
1316 }
1317
1318 impl fmt::Debug for MacroRulesNormalizedIdent {
1319     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1320         fmt::Debug::fmt(&self.0, f)
1321     }
1322 }
1323
1324 impl fmt::Display for MacroRulesNormalizedIdent {
1325     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1326         fmt::Display::fmt(&self.0, f)
1327     }
1328 }
1329
1330 /// An interned string.
1331 ///
1332 /// Internally, a `Symbol` is implemented as an index, and all operations
1333 /// (including hashing, equality, and ordering) operate on that index. The use
1334 /// of `rustc_index::newtype_index!` means that `Option<Symbol>` only takes up 4 bytes,
1335 /// because `rustc_index::newtype_index!` reserves the last 256 values for tagging purposes.
1336 ///
1337 /// Note that `Symbol` cannot directly be a `rustc_index::newtype_index!` because it
1338 /// implements `fmt::Debug`, `Encodable`, and `Decodable` in special ways.
1339 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1340 pub struct Symbol(SymbolIndex);
1341
1342 rustc_index::newtype_index! {
1343     pub struct SymbolIndex { .. }
1344 }
1345
1346 impl Symbol {
1347     const fn new(n: u32) -> Self {
1348         Symbol(SymbolIndex::from_u32(n))
1349     }
1350
1351     /// Maps a string to its interned representation.
1352     pub fn intern(string: &str) -> Self {
1353         with_interner(|interner| interner.intern(string))
1354     }
1355
1356     /// Access the symbol's chars. This is a slowish operation because it
1357     /// requires locking the symbol interner.
1358     pub fn with<F: FnOnce(&str) -> R, R>(self, f: F) -> R {
1359         with_interner(|interner| f(interner.get(self)))
1360     }
1361
1362     /// Convert to a `SymbolStr`. This is a slowish operation because it
1363     /// requires locking the symbol interner.
1364     pub fn as_str(self) -> SymbolStr {
1365         with_interner(|interner| unsafe {
1366             SymbolStr { string: std::mem::transmute::<&str, &str>(interner.get(self)) }
1367         })
1368     }
1369
1370     pub fn as_u32(self) -> u32 {
1371         self.0.as_u32()
1372     }
1373
1374     /// This method is supposed to be used in error messages, so it's expected to be
1375     /// identical to printing the original identifier token written in source code
1376     /// (`token_to_string`, `Ident::to_string`), except that symbols don't keep the rawness flag
1377     /// or edition, so we have to guess the rawness using the global edition.
1378     pub fn to_ident_string(self) -> String {
1379         Ident::with_dummy_span(self).to_string()
1380     }
1381 }
1382
1383 impl fmt::Debug for Symbol {
1384     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1385         self.with(|str| fmt::Debug::fmt(&str, f))
1386     }
1387 }
1388
1389 impl fmt::Display for Symbol {
1390     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1391         self.with(|str| fmt::Display::fmt(&str, f))
1392     }
1393 }
1394
1395 impl Encodable for Symbol {
1396     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
1397         self.with(|string| s.emit_str(string))
1398     }
1399 }
1400
1401 impl Decodable for Symbol {
1402     #[inline]
1403     fn decode<D: Decoder>(d: &mut D) -> Result<Symbol, D::Error> {
1404         Ok(Symbol::intern(&d.read_str()?))
1405     }
1406 }
1407
1408 impl<CTX> HashStable<CTX> for Symbol {
1409     #[inline]
1410     fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
1411         self.as_str().hash_stable(hcx, hasher);
1412     }
1413 }
1414
1415 impl<CTX> ToStableHashKey<CTX> for Symbol {
1416     type KeyType = SymbolStr;
1417
1418     #[inline]
1419     fn to_stable_hash_key(&self, _: &CTX) -> SymbolStr {
1420         self.as_str()
1421     }
1422 }
1423
1424 // The `&'static str`s in this type actually point into the arena.
1425 #[derive(Default)]
1426 pub struct Interner {
1427     arena: DroplessArena,
1428     names: FxHashMap<&'static str, Symbol>,
1429     strings: Vec<&'static str>,
1430 }
1431
1432 impl Interner {
1433     fn prefill(init: &[&'static str]) -> Self {
1434         Interner {
1435             strings: init.into(),
1436             names: init.iter().copied().zip((0..).map(Symbol::new)).collect(),
1437             ..Default::default()
1438         }
1439     }
1440
1441     #[inline]
1442     pub fn intern(&mut self, string: &str) -> Symbol {
1443         if let Some(&name) = self.names.get(string) {
1444             return name;
1445         }
1446
1447         let name = Symbol::new(self.strings.len() as u32);
1448
1449         // `from_utf8_unchecked` is safe since we just allocated a `&str` which is known to be
1450         // UTF-8.
1451         let string: &str =
1452             unsafe { str::from_utf8_unchecked(self.arena.alloc_slice(string.as_bytes())) };
1453         // It is safe to extend the arena allocation to `'static` because we only access
1454         // these while the arena is still alive.
1455         let string: &'static str = unsafe { &*(string as *const str) };
1456         self.strings.push(string);
1457         self.names.insert(string, name);
1458         name
1459     }
1460
1461     // Get the symbol as a string. `Symbol::as_str()` should be used in
1462     // preference to this function.
1463     pub fn get(&self, symbol: Symbol) -> &str {
1464         self.strings[symbol.0.as_usize()]
1465     }
1466 }
1467
1468 // This module has a very short name because it's used a lot.
1469 /// This module contains all the defined keyword `Symbol`s.
1470 ///
1471 /// Given that `kw` is imported, use them like `kw::keyword_name`.
1472 /// For example `kw::Loop` or `kw::Break`.
1473 pub mod kw {
1474     use super::Symbol;
1475     keywords!();
1476 }
1477
1478 // This module has a very short name because it's used a lot.
1479 /// This module contains all the defined non-keyword `Symbol`s.
1480 ///
1481 /// Given that `sym` is imported, use them like `sym::symbol_name`.
1482 /// For example `sym::rustfmt` or `sym::u8`.
1483 #[allow(rustc::default_hash_types)]
1484 pub mod sym {
1485     use super::Symbol;
1486     use std::convert::TryInto;
1487
1488     symbols!();
1489
1490     // Used from a macro in `librustc_feature/accepted.rs`
1491     pub use super::kw::MacroRules as macro_rules;
1492
1493     // Get the symbol for an integer. The first few non-negative integers each
1494     // have a static symbol and therefore are fast.
1495     pub fn integer<N: TryInto<usize> + Copy + ToString>(n: N) -> Symbol {
1496         if let Result::Ok(idx) = n.try_into() {
1497             if let Option::Some(&sym_) = digits_array.get(idx) {
1498                 return sym_;
1499             }
1500         }
1501         Symbol::intern(&n.to_string())
1502     }
1503 }
1504
1505 impl Symbol {
1506     fn is_used_keyword_2018(self) -> bool {
1507         self >= kw::Async && self <= kw::Dyn
1508     }
1509
1510     fn is_unused_keyword_2018(self) -> bool {
1511         self == kw::Try
1512     }
1513
1514     /// Used for sanity checking rustdoc keyword sections.
1515     pub fn is_doc_keyword(self) -> bool {
1516         self <= kw::Union
1517     }
1518
1519     /// A keyword or reserved identifier that can be used as a path segment.
1520     pub fn is_path_segment_keyword(self) -> bool {
1521         self == kw::Super
1522             || self == kw::SelfLower
1523             || self == kw::SelfUpper
1524             || self == kw::Crate
1525             || self == kw::PathRoot
1526             || self == kw::DollarCrate
1527     }
1528
1529     /// Returns `true` if the symbol is `true` or `false`.
1530     pub fn is_bool_lit(self) -> bool {
1531         self == kw::True || self == kw::False
1532     }
1533
1534     /// This symbol can be a raw identifier.
1535     pub fn can_be_raw(self) -> bool {
1536         self != kw::Invalid && self != kw::Underscore && !self.is_path_segment_keyword()
1537     }
1538 }
1539
1540 impl Ident {
1541     // Returns `true` for reserved identifiers used internally for elided lifetimes,
1542     // unnamed method parameters, crate root module, error recovery etc.
1543     pub fn is_special(self) -> bool {
1544         self.name <= kw::Underscore
1545     }
1546
1547     /// Returns `true` if the token is a keyword used in the language.
1548     pub fn is_used_keyword(self) -> bool {
1549         // Note: `span.edition()` is relatively expensive, don't call it unless necessary.
1550         self.name >= kw::As && self.name <= kw::While
1551             || self.name.is_used_keyword_2018() && self.span.rust_2018()
1552     }
1553
1554     /// Returns `true` if the token is a keyword reserved for possible future use.
1555     pub fn is_unused_keyword(self) -> bool {
1556         // Note: `span.edition()` is relatively expensive, don't call it unless necessary.
1557         self.name >= kw::Abstract && self.name <= kw::Yield
1558             || self.name.is_unused_keyword_2018() && self.span.rust_2018()
1559     }
1560
1561     /// Returns `true` if the token is either a special identifier or a keyword.
1562     pub fn is_reserved(self) -> bool {
1563         self.is_special() || self.is_used_keyword() || self.is_unused_keyword()
1564     }
1565
1566     /// A keyword or reserved identifier that can be used as a path segment.
1567     pub fn is_path_segment_keyword(self) -> bool {
1568         self.name.is_path_segment_keyword()
1569     }
1570
1571     /// We see this identifier in a normal identifier position, like variable name or a type.
1572     /// How was it written originally? Did it use the raw form? Let's try to guess.
1573     pub fn is_raw_guess(self) -> bool {
1574         self.name.can_be_raw() && self.is_reserved()
1575     }
1576 }
1577
1578 #[inline]
1579 fn with_interner<T, F: FnOnce(&mut Interner) -> T>(f: F) -> T {
1580     SESSION_GLOBALS.with(|session_globals| f(&mut *session_globals.symbol_interner.lock()))
1581 }
1582
1583 /// An alternative to `Symbol`, useful when the chars within the symbol need to
1584 /// be accessed. It deliberately has limited functionality and should only be
1585 /// used for temporary values.
1586 ///
1587 /// Because the interner outlives any thread which uses this type, we can
1588 /// safely treat `string` which points to interner data, as an immortal string,
1589 /// as long as this type never crosses between threads.
1590 //
1591 // FIXME: ensure that the interner outlives any thread which uses `SymbolStr`,
1592 // by creating a new thread right after constructing the interner.
1593 #[derive(Clone, Eq, PartialOrd, Ord)]
1594 pub struct SymbolStr {
1595     string: &'static str,
1596 }
1597
1598 // This impl allows a `SymbolStr` to be directly equated with a `String` or
1599 // `&str`.
1600 impl<T: std::ops::Deref<Target = str>> std::cmp::PartialEq<T> for SymbolStr {
1601     fn eq(&self, other: &T) -> bool {
1602         self.string == other.deref()
1603     }
1604 }
1605
1606 impl !Send for SymbolStr {}
1607 impl !Sync for SymbolStr {}
1608
1609 /// This impl means that if `ss` is a `SymbolStr`:
1610 /// - `*ss` is a `str`;
1611 /// - `&*ss` is a `&str` (and `match &*ss { ... }` is a common pattern).
1612 /// - `&ss as &str` is a `&str`, which means that `&ss` can be passed to a
1613 ///   function expecting a `&str`.
1614 impl std::ops::Deref for SymbolStr {
1615     type Target = str;
1616     #[inline]
1617     fn deref(&self) -> &str {
1618         self.string
1619     }
1620 }
1621
1622 impl fmt::Debug for SymbolStr {
1623     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1624         fmt::Debug::fmt(self.string, f)
1625     }
1626 }
1627
1628 impl fmt::Display for SymbolStr {
1629     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1630         fmt::Display::fmt(self.string, f)
1631     }
1632 }
1633
1634 impl<CTX> HashStable<CTX> for SymbolStr {
1635     #[inline]
1636     fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
1637         self.string.hash_stable(hcx, hasher)
1638     }
1639 }
1640
1641 impl<CTX> ToStableHashKey<CTX> for SymbolStr {
1642     type KeyType = SymbolStr;
1643
1644     #[inline]
1645     fn to_stable_hash_key(&self, _: &CTX) -> SymbolStr {
1646         self.clone()
1647     }
1648 }