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