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