//! An "interner" is a data structure that associates values with usize tags and //! allows bidirectional lookup; i.e., given a value, one can easily find the //! type, and vice versa. use rustc_arena::DroplessArena; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey}; use rustc_data_structures::sync::Lock; use rustc_macros::HashStable_Generic; use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; use std::cmp::{Ord, PartialEq, PartialOrd}; use std::fmt; use std::hash::{Hash, Hasher}; use std::str; use crate::{with_session_globals, Edition, Span, DUMMY_SP}; #[cfg(test)] mod tests; // The proc macro code for this is in `compiler/rustc_macros/src/symbols.rs`. symbols! { // After modifying this list adjust `is_special`, `is_used_keyword`/`is_unused_keyword`, // this should be rarely necessary though if the keywords are kept in alphabetic order. Keywords { // Special reserved identifiers used internally for elided lifetimes, // unnamed method parameters, crate root module, error recovery etc. Empty: "", PathRoot: "{{root}}", DollarCrate: "$crate", Underscore: "_", // Keywords that are used in stable Rust. As: "as", Break: "break", Const: "const", Continue: "continue", Crate: "crate", Else: "else", Enum: "enum", Extern: "extern", False: "false", Fn: "fn", For: "for", If: "if", Impl: "impl", In: "in", Let: "let", Loop: "loop", Match: "match", Mod: "mod", Move: "move", Mut: "mut", Pub: "pub", Ref: "ref", Return: "return", SelfLower: "self", SelfUpper: "Self", Static: "static", Struct: "struct", Super: "super", Trait: "trait", True: "true", Type: "type", Unsafe: "unsafe", Use: "use", Where: "where", While: "while", // Keywords that are used in unstable Rust or reserved for future use. Abstract: "abstract", Become: "become", Box: "box", Do: "do", Final: "final", Macro: "macro", Override: "override", Priv: "priv", Typeof: "typeof", Unsized: "unsized", Virtual: "virtual", Yield: "yield", // Edition-specific keywords that are used in stable Rust. Async: "async", // >= 2018 Edition only Await: "await", // >= 2018 Edition only Dyn: "dyn", // >= 2018 Edition only // Edition-specific keywords that are used in unstable Rust or reserved for future use. Try: "try", // >= 2018 Edition only // Special lifetime names UnderscoreLifetime: "'_", StaticLifetime: "'static", // Weak keywords, have special meaning only in specific contexts. Auto: "auto", Catch: "catch", Default: "default", MacroRules: "macro_rules", Raw: "raw", Union: "union", Yeet: "yeet", } // Pre-interned symbols that can be referred to with `rustc_span::sym::*`. // // The symbol is the stringified identifier unless otherwise specified, in // which case the name should mention the non-identifier punctuation. // E.g. `sym::proc_dash_macro` represents "proc-macro", and it shouldn't be // called `sym::proc_macro` because then it's easy to mistakenly think it // represents "proc_macro". // // As well as the symbols listed, there are symbols for the strings // "0", "1", ..., "9", which are accessible via `sym::integer`. // // The proc macro will abort if symbols are not in alphabetical order (as // defined by `impl Ord for str`) or if any symbols are duplicated. Vim // users can sort the list by selecting it and executing the command // `:'<,'>!LC_ALL=C sort`. // // There is currently no checking that all symbols are used; that would be // nice to have. Symbols { AcqRel, Acquire, AddSubdiagnostic, Alignment, Any, Arc, Argument, ArgumentV1, ArgumentV1Methods, Arguments, AsMut, AsRef, AssertParamIsClone, AssertParamIsCopy, AssertParamIsEq, AtomicBool, AtomicI128, AtomicI16, AtomicI32, AtomicI64, AtomicI8, AtomicIsize, AtomicPtr, AtomicU128, AtomicU16, AtomicU32, AtomicU64, AtomicU8, AtomicUsize, BTreeEntry, BTreeMap, BTreeSet, BinaryHeap, Borrow, Break, C, CStr, CString, Capture, Center, Clone, Continue, Copy, Count, Cow, Debug, DebugStruct, DebugTuple, Decodable, Decoder, DecorateLint, Default, Deref, DiagnosticMessage, DirBuilder, Display, DoubleEndedIterator, Duration, Encodable, Encoder, Eq, Equal, Err, Error, File, FileType, Fn, FnMut, FnOnce, FormatSpec, Formatter, From, FromIterator, FromResidual, Future, FxHashMap, FxHashSet, GlobalAlloc, Hash, HashMap, HashMapEntry, HashSet, Hasher, Implied, Input, Into, IntoFuture, IntoIterator, IoRead, IoWrite, IrTyKind, Is, ItemContext, Iterator, Layout, Left, LinkedList, LintPass, Mutex, N, NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroU128, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, None, Ok, Option, Ord, Ordering, OsStr, OsString, Output, Param, PartialEq, PartialOrd, Path, PathBuf, Pending, Pin, Pointer, Poll, ProcMacro, ProcMacroHack, ProceduralMasqueradeDummyType, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive, Rc, Ready, Receiver, Relaxed, Release, Result, Return, Right, Rust, RustcDecodable, RustcEncodable, Send, SeqCst, SessionDiagnostic, SliceIndex, Some, String, StructuralEq, StructuralPartialEq, SubdiagnosticMessage, Sync, Target, ToOwned, ToString, Try, TryCaptureGeneric, TryCapturePrintable, TryFrom, TryInto, Ty, TyCtxt, TyKind, Unknown, UnsafeArg, Vec, VecDeque, Wrapper, Yield, _DECLS, _Self, __D, __H, __S, __awaitee, __try_var, _d, _e, _task_context, a32, aarch64_target_feature, aarch64_ver_target_feature, abi, abi_amdgpu_kernel, abi_avr_interrupt, abi_c_cmse_nonsecure_call, abi_efiapi, abi_msp430_interrupt, abi_ptx, abi_sysv64, abi_thiscall, abi_unadjusted, abi_vectorcall, abi_x86_interrupt, abort, aborts, add, add_assign, add_with_overflow, address, adt_const_params, advanced_slice_patterns, adx_target_feature, alias, align, align_offset, alignstack, all, alloc, alloc_error_handler, alloc_layout, alloc_zeroed, allocator, allocator_api, allocator_internals, allow, allow_fail, allow_internal_unsafe, allow_internal_unstable, allowed, alu32, always, and, and_then, anonymous_lifetime_in_impl_trait, any, append_const_msg, arbitrary_enum_discriminant, arbitrary_self_types, args, arith_offset, arm, arm_target_feature, array, arrays, as_ptr, as_ref, as_str, asm, asm_const, asm_experimental_arch, asm_sym, asm_unwind, assert, assert_eq_macro, assert_inhabited, assert_macro, assert_ne_macro, assert_receiver_is_total_eq, assert_uninit_valid, assert_zero_valid, asserting, associated_const_equality, associated_consts, associated_type_bounds, associated_type_defaults, associated_types, assume, assume_init, async_await, async_closure, atomic, atomic_mod, atomics, att_syntax, attr, attr_literals, attributes, augmented_assignments, auto_traits, automatically_derived, avx, avx512_target_feature, avx512bw, avx512f, await_macro, bang, begin_panic, bench, bin, bind_by_move_pattern_guards, bindings_after_at, bitand, bitand_assign, bitor, bitor_assign, bitreverse, bitxor, bitxor_assign, black_box, block, bool, borrowck_graphviz_format, borrowck_graphviz_postflow, borrowck_graphviz_preflow, box_free, box_patterns, box_syntax, bpf_target_feature, braced_empty_structs, branch, breakpoint, bridge, bswap, c_str, c_unwind, c_variadic, call, call_mut, call_once, caller_location, capture_disjoint_fields, cdylib, ceilf32, ceilf64, cfg, cfg_accessible, cfg_attr, cfg_attr_multi, cfg_doctest, cfg_eval, cfg_hide, cfg_macro, cfg_panic, cfg_sanitize, cfg_target_abi, cfg_target_compact, cfg_target_feature, cfg_target_has_atomic, cfg_target_has_atomic_equal_alignment, cfg_target_has_atomic_load_store, cfg_target_thread_local, cfg_target_vendor, cfg_version, cfi, char, client, clippy, clobber_abi, clone, clone_closures, clone_from, closure, closure_lifetime_binder, closure_to_fn_coercion, closure_track_caller, cmp, cmp_max, cmp_min, cmpxchg16b_target_feature, cmse_nonsecure_entry, coerce_unsized, cold, column, column_macro, compare_and_swap, compare_exchange, compare_exchange_weak, compile_error, compile_error_macro, compiler, compiler_builtins, compiler_fence, concat, concat_bytes, concat_idents, concat_macro, conservative_impl_trait, console, const_allocate, const_async_blocks, const_compare_raw_pointers, const_constructor, const_deallocate, const_eval_limit, const_eval_select, const_eval_select_ct, const_evaluatable_checked, const_extern_fn, const_fn, const_fn_floating_point_arithmetic, const_fn_fn_ptr_basics, const_fn_trait_bound, const_fn_transmute, const_fn_union, const_fn_unsize, const_for, const_format_args, const_generic_defaults, const_generics, const_generics_defaults, const_if_match, const_impl_trait, const_in_array_repeat_expressions, const_indexing, const_let, const_loop, const_mut_refs, const_panic, const_panic_fmt, const_precise_live_drops, const_raw_ptr_deref, const_raw_ptr_to_usize_cast, const_refs_to_cell, const_trait, const_trait_bound_opt_out, const_trait_impl, const_transmute, const_try, constant, constructor, contents, context, convert, copy, copy_closures, copy_nonoverlapping, copysignf32, copysignf64, core, core_intrinsics, core_panic, core_panic_2015_macro, core_panic_macro, cosf32, cosf64, count, cr, crate_id, crate_in_paths, crate_local, crate_name, crate_type, crate_visibility_modifier, crt_dash_static: "crt-static", cstring_type, ctlz, ctlz_nonzero, ctpop, cttz, cttz_nonzero, custom_attribute, custom_derive, custom_inner_attributes, custom_test_frameworks, d, d32, dbg_macro, dead_code, dealloc, debug, debug_assert_eq_macro, debug_assert_macro, debug_assert_ne_macro, debug_assertions, debug_struct, debug_struct_fields_finish, debug_trait_builder, debug_tuple, debug_tuple_fields_finish, debugger_visualizer, decl_macro, declare_lint_pass, decode, default_alloc_error_handler, default_lib_allocator, default_method_body_is_const, default_type_parameter_fallback, default_type_params, delay_span_bug_from_inside_query, deny, deprecated, deprecated_safe, deprecated_suggestion, deref, deref_method, deref_mut, deref_target, derive, derive_default_enum, destruct, destructuring_assignment, diagnostic, direct, discriminant_kind, discriminant_type, discriminant_value, dispatch_from_dyn, display_trait, div, div_assign, doc, doc_alias, doc_auto_cfg, doc_cfg, doc_cfg_hide, doc_keyword, doc_masked, doc_notable_trait, doc_primitive, doc_spotlight, doctest, document_private_items, dotdot: "..", dotdot_in_tuple_patterns, dotdoteq_in_patterns, dreg, dreg_low16, dreg_low8, drop, drop_in_place, drop_types_in_const, dropck_eyepatch, dropck_parametricity, dylib, dyn_metadata, dyn_trait, e, edition_macro_pats, edition_panic, eh_catch_typeinfo, eh_personality, emit_enum, emit_enum_variant, emit_enum_variant_arg, emit_struct, emit_struct_field, enable, enclosing_scope, encode, end, env, env_macro, eprint_macro, eprintln_macro, eq, ermsb_target_feature, exact_div, except, exchange_malloc, exclusive_range_pattern, exhaustive_integer_patterns, exhaustive_patterns, existential_type, exp2f32, exp2f64, expect, expected, expf32, expf64, explicit_generic_args_with_impl_trait, export_name, expr, extended_key_value_attributes, extern_absolute_paths, extern_crate_item_prelude, extern_crate_self, extern_in_paths, extern_prelude, extern_types, external_doc, f, f16c_target_feature, f32, f64, fabsf32, fabsf64, fadd_fast, fake_variadic, fdiv_fast, feature, fence, ferris: "🦀", fetch_update, ffi, ffi_const, ffi_pure, ffi_returns_twice, field, field_init_shorthand, file, file_macro, fill, finish, flags, float, float_to_int_unchecked, floorf32, floorf64, fmaf32, fmaf64, fmt, fmt_as_str, fmt_internals, fmul_fast, fn_align, fn_must_use, fn_mut, fn_once, fn_once_output, forbid, forget, format, format_args, format_args_capture, format_args_macro, format_args_nl, format_macro, fp, freeze, freg, frem_fast, from, from_desugaring, from_generator, from_iter, from_method, from_output, from_residual, from_size_align_unchecked, from_usize, from_yeet, fsub_fast, fundamental, future, future_trait, gdb_script_file, ge, gen_future, gen_kill, generator, generator_return, generator_state, generators, generic_arg_infer, generic_assert, generic_associated_types, generic_associated_types_extended, generic_const_exprs, generic_param_attrs, get_context, global_allocator, global_asm, globs, gt, half_open_range_patterns, hash, hexagon_target_feature, hidden, homogeneous_aggregate, html_favicon_url, html_logo_url, html_no_source, html_playground_url, html_root_url, hwaddress, i, i128, i128_type, i16, i32, i64, i8, ident, if_let, if_let_guard, if_while_or_patterns, ignore, impl_header_lifetime_elision, impl_lint_pass, impl_macros, impl_trait_in_bindings, implied_by, import, import_shadowing, imported_main, in_band_lifetimes, include, include_bytes, include_bytes_macro, include_macro, include_str, include_str_macro, inclusive_range_syntax, index, index_mut, infer_outlives_requirements, infer_static_outlives_requirements, inherent_associated_types, inlateout, inline, inline_const, inline_const_pat, inout, instruction_set, integer_: "integer", integral, intel, into_future, into_iter, intra_doc_pointers, intrinsics, irrefutable_let_patterns, isa_attribute, isize, issue, issue_5723_bootstrap, issue_tracker_base_url, item, item_like_imports, iter, iter_repeat, keyword, kind, kreg, kreg0, label, label_break_value, lang, lang_items, large_assignments, lateout, lazy_normalization_consts, le, len, let_chains, let_else, lhs, lib, libc, lifetime, likely, line, line_macro, link, link_args, link_cfg, link_llvm_intrinsics, link_name, link_ordinal, link_section, linkage, linker, lint_reasons, literal, load, loaded_from_disk, local, local_inner_macros, log10f32, log10f64, log2f32, log2f64, log_syntax, logf32, logf64, loop_break_value, lt, macro_at_most_once_rep, macro_attributes_in_derive_output, macro_escape, macro_export, macro_lifetime_matcher, macro_literal_matcher, macro_metavar_expr, macro_reexport, macro_use, macro_vis_matcher, macros_in_extern, main, managed_boxes, manually_drop, map, marker, marker_trait_attr, masked, match_beginning_vert, match_default_bindings, matches_macro, maxnumf32, maxnumf64, may_dangle, may_unwind, maybe_uninit, maybe_uninit_uninit, maybe_uninit_zeroed, mem_discriminant, mem_drop, mem_forget, mem_replace, mem_size_of, mem_size_of_val, mem_uninitialized, mem_variant_count, mem_zeroed, member_constraints, memory, memtag, message, meta, metadata_type, min_align_of, min_align_of_val, min_const_fn, min_const_generics, min_const_unsafe_fn, min_specialization, min_type_alias_impl_trait, minnumf32, minnumf64, mips_target_feature, miri, misc, mmx_reg, modifiers, module, module_path, module_path_macro, more_qualified_paths, more_struct_aliases, movbe_target_feature, move_ref_pattern, move_size_limit, mul, mul_assign, mul_with_overflow, must_not_suspend, must_use, naked, naked_functions, name, names, native_link_modifiers, native_link_modifiers_as_needed, native_link_modifiers_bundle, native_link_modifiers_verbatim, native_link_modifiers_whole_archive, natvis_file, ne, nearbyintf32, nearbyintf64, needs_allocator, needs_drop, needs_panic_runtime, neg, negate_unsigned, negative_impls, neon, never, never_type, never_type_fallback, new, new_unchecked, next, nll, no, no_builtins, no_core, no_coverage, no_crate_inject, no_debug, no_default_passes, no_implicit_prelude, no_inline, no_link, no_main, no_mangle, no_sanitize, no_stack_check, no_start, no_std, nomem, non_ascii_idents, non_exhaustive, non_exhaustive_omitted_patterns_lint, non_modrs_mods, none_error, nontemporal_store, noop_method_borrow, noop_method_clone, noop_method_deref, noreturn, nostack, not, notable_trait, note, object_safe_for_dispatch, of, offset, omit_gdb_pretty_printer_section, on, on_unimplemented, oom, opaque, ops, opt_out_copy, optimize, optimize_attribute, optin_builtin_traits, option, option_env, option_env_macro, options, or, or_patterns, other, out, overlapping_marker_traits, owned_box, packed, panic, panic_2015, panic_2021, panic_abort, panic_bounds_check, panic_display, panic_fmt, panic_handler, panic_impl, panic_implementation, panic_info, panic_location, panic_no_unwind, panic_runtime, panic_str, panic_unwind, panicking, param_attrs, partial_cmp, partial_ord, passes, pat, pat_param, path, pattern_parentheses, phantom_data, pin, platform_intrinsics, plugin, plugin_registrar, plugins, pointee_trait, pointer, pointer_trait_fmt, poll, position, post_dash_lto: "post-lto", powerpc_target_feature, powf32, powf64, powif32, powif64, pre_dash_lto: "pre-lto", precise_pointer_size_matching, precision, pref_align_of, prefetch_read_data, prefetch_read_instruction, prefetch_write_data, prefetch_write_instruction, preg, prelude, prelude_import, preserves_flags, primitive, print_macro, println_macro, proc_dash_macro: "proc-macro", proc_macro, proc_macro_attribute, proc_macro_def_site, proc_macro_derive, proc_macro_expr, proc_macro_gen, proc_macro_hygiene, proc_macro_internals, proc_macro_mod, proc_macro_non_items, proc_macro_path_invoc, profiler_builtins, profiler_runtime, ptr, ptr_guaranteed_eq, ptr_guaranteed_ne, ptr_null, ptr_null_mut, ptr_offset_from, ptr_offset_from_unsigned, pub_macro_rules, pub_restricted, pure, pushpop_unsafe, qreg, qreg_low4, qreg_low8, quad_precision_float, question_mark, quote, range_inclusive_new, raw_dylib, raw_eq, raw_identifiers, raw_ref_op, re_rebalance_coherence, read_enum, read_enum_variant, read_enum_variant_arg, read_struct, read_struct_field, readonly, realloc, reason, receiver, recursion_limit, reexport_test_harness_main, ref_unwind_safe_trait, reference, reflect, reg, reg16, reg32, reg64, reg_abcd, reg_byte, reg_iw, reg_nonzero, reg_pair, reg_ptr, reg_upper, register_attr, register_tool, relaxed_adts, relaxed_struct_unsize, rem, rem_assign, repr, repr128, repr_align, repr_align_enum, repr_packed, repr_simd, repr_transparent, residual, result, rhs, rintf32, rintf64, riscv_target_feature, rlib, rotate_left, rotate_right, roundf32, roundf64, rt, rtm_target_feature, rust, rust_2015, rust_2015_preview, rust_2018, rust_2018_preview, rust_2021, rust_2021_preview, rust_2024, rust_2024_preview, rust_begin_unwind, rust_cold_cc, rust_eh_catch_typeinfo, rust_eh_personality, rust_eh_register_frames, rust_eh_unregister_frames, rust_oom, rustc, rustc_allocator, rustc_allocator_nounwind, rustc_allocator_zeroed, rustc_allow_const_fn_unstable, rustc_allow_incoherent_impl, rustc_allowed_through_unstable_modules, rustc_attrs, rustc_box, rustc_builtin_macro, rustc_capture_analysis, rustc_clean, rustc_coherence_is_core, rustc_const_stable, rustc_const_unstable, rustc_conversion_suggestion, rustc_deallocator, rustc_def_path, rustc_diagnostic_item, rustc_diagnostic_macros, rustc_dirty, rustc_do_not_const_check, rustc_dummy, rustc_dump_env_program_clauses, rustc_dump_program_clauses, rustc_dump_user_substs, rustc_dump_vtable, rustc_error, rustc_evaluate_where_clauses, rustc_expected_cgu_reuse, rustc_has_incoherent_inherent_impls, rustc_if_this_changed, rustc_inherit_overflow_checks, rustc_insignificant_dtor, rustc_layout, rustc_layout_scalar_valid_range_end, rustc_layout_scalar_valid_range_start, rustc_legacy_const_generics, rustc_lint_diagnostics, rustc_lint_opt_deny_field_access, rustc_lint_opt_ty, rustc_lint_query_instability, rustc_macro_transparency, rustc_main, rustc_mir, rustc_must_implement_one_of, rustc_nonnull_optimization_guaranteed, rustc_object_lifetime_default, rustc_on_unimplemented, rustc_outlives, rustc_paren_sugar, rustc_partition_codegened, rustc_partition_reused, rustc_pass_by_value, rustc_peek, rustc_peek_definite_init, rustc_peek_liveness, rustc_peek_maybe_init, rustc_peek_maybe_uninit, rustc_polymorphize_error, rustc_private, rustc_proc_macro_decls, rustc_promotable, rustc_reallocator, rustc_regions, rustc_reservation_impl, rustc_serialize, rustc_skip_array_during_method_dispatch, rustc_specialization_trait, rustc_stable, rustc_std_internal_symbol, rustc_strict_coherence, rustc_symbol_name, rustc_test_marker, rustc_then_this_would_need, rustc_trivial_field_reads, rustc_unsafe_specialization_marker, rustc_variance, rustdoc, rustdoc_internals, rustfmt, rvalue_static_promotion, s, sanitize, sanitizer_runtime, saturating_add, saturating_sub, self_in_typedefs, self_struct_ctor, semitransparent, shadow_call_stack, shl, shl_assign, should_panic, shr, shr_assign, simd, simd_add, simd_and, simd_arith_offset, simd_as, simd_bitmask, simd_cast, simd_ceil, simd_div, simd_eq, simd_extract, simd_fabs, simd_fcos, simd_fexp, simd_fexp2, simd_ffi, simd_flog, simd_flog10, simd_flog2, simd_floor, simd_fma, simd_fmax, simd_fmin, simd_fpow, simd_fpowi, simd_fsin, simd_fsqrt, simd_gather, simd_ge, simd_gt, simd_insert, simd_le, simd_lt, simd_mul, simd_ne, simd_neg, simd_or, simd_reduce_add_ordered, simd_reduce_add_unordered, simd_reduce_all, simd_reduce_and, simd_reduce_any, simd_reduce_max, simd_reduce_max_nanless, simd_reduce_min, simd_reduce_min_nanless, simd_reduce_mul_ordered, simd_reduce_mul_unordered, simd_reduce_or, simd_reduce_xor, simd_rem, simd_round, simd_saturating_add, simd_saturating_sub, simd_scatter, simd_select, simd_select_bitmask, simd_shl, simd_shr, simd_shuffle, simd_sub, simd_trunc, simd_xor, since, sinf32, sinf64, size, size_of, size_of_val, sized, skip, slice, slice_len_fn, slice_patterns, slicing_syntax, soft, specialization, speed, spotlight, sqrtf32, sqrtf64, sreg, sreg_low16, sse, sse4a_target_feature, stable, staged_api, start, state, static_in_const, static_nobundle, static_recursion, staticlib, std, std_inject, std_panic, std_panic_2015_macro, std_panic_macro, stmt, stmt_expr_attributes, stop_after_dataflow, store, str, str_split_whitespace, str_trim, str_trim_end, str_trim_start, strict_provenance, stringify, stringify_macro, struct_field_attributes, struct_inherit, struct_variant, structural_match, structural_peq, structural_teq, sty, sub, sub_assign, sub_with_overflow, suggestion, sym, sync, t32, target, target_abi, target_arch, target_endian, target_env, target_family, target_feature, target_feature_11, target_has_atomic, target_has_atomic_equal_alignment, target_has_atomic_load_store, target_os, target_pointer_width, target_target_vendor, target_thread_local, target_vendor, task, tbm_target_feature, termination, termination_trait, termination_trait_test, test, test_2018_feature, test_accepted_feature, test_case, test_removed_feature, test_runner, test_unstable_lint, then_with, thread, thread_local, thread_local_macro, thumb2, thumb_mode: "thumb-mode", tmm_reg, to_string, to_vec, todo_macro, tool_attributes, tool_lints, trace_macros, track_caller, trait_alias, trait_upcasting, transmute, transparent, transparent_enums, transparent_unions, trivial_bounds, truncf32, truncf64, try_blocks, try_capture, try_from, try_into, try_trait_v2, tt, tuple, tuple_from_req, tuple_indexing, two_phase, ty, type_alias_enum_variants, type_alias_impl_trait, type_ascription, type_changing_struct_update, type_id, type_length_limit, type_macros, type_name, u128, u16, u32, u64, u8, unaligned_volatile_load, unaligned_volatile_store, unboxed_closures, unchecked_add, unchecked_div, unchecked_mul, unchecked_rem, unchecked_shl, unchecked_shr, unchecked_sub, underscore_const_names, underscore_imports, underscore_lifetimes, uniform_paths, unimplemented_macro, unit, universal_impl_trait, unix, unlikely, unmarked_api, unpin, unreachable, unreachable_2015, unreachable_2015_macro, unreachable_2021, unreachable_2021_macro, unreachable_code, unreachable_display, unreachable_macro, unrestricted_attribute_tokens, unsafe_block_in_unsafe_fn, unsafe_cell, unsafe_no_drop_flag, unsafe_pin_internals, unsize, unsized_fn_params, unsized_locals, unsized_tuple_coercion, unstable, unstable_location_reason_default: "this crate is being loaded from the sysroot, an \ unstable location; did you mean to load this crate \ from crates.io via `Cargo.toml` instead?", untagged_unions, unused_imports, unused_qualifications, unwind, unwind_attributes, unwind_safe_trait, unwrap, unwrap_or, use_extern_macros, use_nested_groups, used, used_with_arg, using, usize, v1, va_arg, va_copy, va_end, va_list, va_start, val, values, var, variant_count, vec, vec_macro, version, vfp2, vis, visible_private_types, volatile, volatile_copy_memory, volatile_copy_nonoverlapping_memory, volatile_load, volatile_set_memory, volatile_store, vreg, vreg_low16, vtable_align, vtable_size, warn, wasm_abi, wasm_import_module, wasm_target_feature, while_let, width, windows, windows_subsystem, with_negative_coherence, wrapping_add, wrapping_mul, wrapping_sub, wreg, write_bytes, write_macro, write_str, writeln_macro, x87_reg, xer, xmm_reg, yeet_desugar_details, yeet_expr, ymm_reg, zmm_reg, } } #[derive(Copy, Clone, Eq, HashStable_Generic, Encodable, Decodable)] pub struct Ident { pub name: Symbol, pub span: Span, } impl Ident { #[inline] /// Constructs a new identifier from a symbol and a span. pub const fn new(name: Symbol, span: Span) -> Ident { Ident { name, span } } /// Constructs a new identifier with a dummy span. #[inline] pub const fn with_dummy_span(name: Symbol) -> Ident { Ident::new(name, DUMMY_SP) } #[inline] pub fn empty() -> Ident { Ident::with_dummy_span(kw::Empty) } /// Maps a string to an identifier with a dummy span. pub fn from_str(string: &str) -> Ident { Ident::with_dummy_span(Symbol::intern(string)) } /// Maps a string and a span to an identifier. pub fn from_str_and_span(string: &str, span: Span) -> Ident { Ident::new(Symbol::intern(string), span) } /// Replaces `lo` and `hi` with those from `span`, but keep hygiene context. pub fn with_span_pos(self, span: Span) -> Ident { Ident::new(self.name, span.with_ctxt(self.span.ctxt())) } pub fn without_first_quote(self) -> Ident { Ident::new(Symbol::intern(self.as_str().trim_start_matches('\'')), self.span) } /// "Normalize" ident for use in comparisons using "item hygiene". /// Identifiers with same string value become same if they came from the same macro 2.0 macro /// (e.g., `macro` item, but not `macro_rules` item) and stay different if they came from /// different macro 2.0 macros. /// Technically, this operation strips all non-opaque marks from ident's syntactic context. pub fn normalize_to_macros_2_0(self) -> Ident { Ident::new(self.name, self.span.normalize_to_macros_2_0()) } /// "Normalize" ident for use in comparisons using "local variable hygiene". /// Identifiers with same string value become same if they came from the same non-transparent /// macro (e.g., `macro` or `macro_rules!` items) and stay different if they came from different /// non-transparent macros. /// Technically, this operation strips all transparent marks from ident's syntactic context. pub fn normalize_to_macro_rules(self) -> Ident { Ident::new(self.name, self.span.normalize_to_macro_rules()) } /// Access the underlying string. This is a slowish operation because it /// requires locking the symbol interner. /// /// Note that the lifetime of the return value is a lie. See /// `Symbol::as_str()` for details. pub fn as_str(&self) -> &str { self.name.as_str() } } impl PartialEq for Ident { fn eq(&self, rhs: &Self) -> bool { self.name == rhs.name && self.span.eq_ctxt(rhs.span) } } impl Hash for Ident { fn hash(&self, state: &mut H) { self.name.hash(state); self.span.ctxt().hash(state); } } impl fmt::Debug for Ident { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(self, f)?; fmt::Debug::fmt(&self.span.ctxt(), f) } } /// This implementation is supposed to be used in error messages, so it's expected to be identical /// to printing the original identifier token written in source code (`token_to_string`), /// except that AST identifiers don't keep the rawness flag, so we have to guess it. impl fmt::Display for Ident { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(&IdentPrinter::new(self.name, self.is_raw_guess(), None), f) } } /// This is the most general way to print identifiers. /// AST pretty-printer is used as a fallback for turning AST structures into token streams for /// proc macros. Additionally, proc macros may stringify their input and expect it survive the /// stringification (especially true for proc macro derives written between Rust 1.15 and 1.30). /// So we need to somehow pretty-print `$crate` in a way preserving at least some of its /// hygiene data, most importantly name of the crate it refers to. /// As a result we print `$crate` as `crate` if it refers to the local crate /// and as `::other_crate_name` if it refers to some other crate. /// Note, that this is only done if the ident token is printed from inside of AST pretty-printing, /// but not otherwise. Pretty-printing is the only way for proc macros to discover token contents, /// so we should not perform this lossy conversion if the top level call to the pretty-printer was /// done for a token stream or a single token. pub struct IdentPrinter { symbol: Symbol, is_raw: bool, /// Span used for retrieving the crate name to which `$crate` refers to, /// if this field is `None` then the `$crate` conversion doesn't happen. convert_dollar_crate: Option, } impl IdentPrinter { /// The most general `IdentPrinter` constructor. Do not use this. pub fn new(symbol: Symbol, is_raw: bool, convert_dollar_crate: Option) -> IdentPrinter { IdentPrinter { symbol, is_raw, convert_dollar_crate } } /// This implementation is supposed to be used when printing identifiers /// as a part of pretty-printing for larger AST pieces. /// Do not use this either. pub fn for_ast_ident(ident: Ident, is_raw: bool) -> IdentPrinter { IdentPrinter::new(ident.name, is_raw, Some(ident.span)) } } impl fmt::Display for IdentPrinter { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if self.is_raw { f.write_str("r#")?; } else if self.symbol == kw::DollarCrate { if let Some(span) = self.convert_dollar_crate { let converted = span.ctxt().dollar_crate_name(); if !converted.is_path_segment_keyword() { f.write_str("::")?; } return fmt::Display::fmt(&converted, f); } } fmt::Display::fmt(&self.symbol, f) } } /// An newtype around `Ident` that calls [Ident::normalize_to_macro_rules] on /// construction. // FIXME(matthewj, petrochenkov) Use this more often, add a similar // `ModernIdent` struct and use that as well. #[derive(Copy, Clone, Eq, PartialEq, Hash)] pub struct MacroRulesNormalizedIdent(Ident); impl MacroRulesNormalizedIdent { pub fn new(ident: Ident) -> Self { Self(ident.normalize_to_macro_rules()) } } impl fmt::Debug for MacroRulesNormalizedIdent { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Debug::fmt(&self.0, f) } } impl fmt::Display for MacroRulesNormalizedIdent { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(&self.0, f) } } /// An interned string. /// /// Internally, a `Symbol` is implemented as an index, and all operations /// (including hashing, equality, and ordering) operate on that index. The use /// of `rustc_index::newtype_index!` means that `Option` only takes up 4 bytes, /// because `rustc_index::newtype_index!` reserves the last 256 values for tagging purposes. /// /// Note that `Symbol` cannot directly be a `rustc_index::newtype_index!` because it /// implements `fmt::Debug`, `Encodable`, and `Decodable` in special ways. #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct Symbol(SymbolIndex); rustc_index::newtype_index! { struct SymbolIndex { .. } } impl Symbol { const fn new(n: u32) -> Self { Symbol(SymbolIndex::from_u32(n)) } /// Maps a string to its interned representation. pub fn intern(string: &str) -> Self { with_session_globals(|session_globals| session_globals.symbol_interner.intern(string)) } /// Access the underlying string. This is a slowish operation because it /// requires locking the symbol interner. /// /// Note that the lifetime of the return value is a lie. It's not the same /// as `&self`, but actually tied to the lifetime of the underlying /// interner. Interners are long-lived, and there are very few of them, and /// this function is typically used for short-lived things, so in practice /// it works out ok. pub fn as_str(&self) -> &str { with_session_globals(|session_globals| unsafe { std::mem::transmute::<&str, &str>(session_globals.symbol_interner.get(*self)) }) } pub fn as_u32(self) -> u32 { self.0.as_u32() } pub fn is_empty(self) -> bool { self == kw::Empty } /// This method is supposed to be used in error messages, so it's expected to be /// identical to printing the original identifier token written in source code /// (`token_to_string`, `Ident::to_string`), except that symbols don't keep the rawness flag /// or edition, so we have to guess the rawness using the global edition. pub fn to_ident_string(self) -> String { Ident::with_dummy_span(self).to_string() } } impl fmt::Debug for Symbol { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Debug::fmt(self.as_str(), f) } } impl fmt::Display for Symbol { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(self.as_str(), f) } } impl Encodable for Symbol { fn encode(&self, s: &mut S) { s.emit_str(self.as_str()); } } impl Decodable for Symbol { #[inline] fn decode(d: &mut D) -> Symbol { Symbol::intern(&d.read_str()) } } impl HashStable for Symbol { #[inline] fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) { self.as_str().hash_stable(hcx, hasher); } } impl ToStableHashKey for Symbol { type KeyType = String; #[inline] fn to_stable_hash_key(&self, _: &CTX) -> String { self.as_str().to_string() } } #[derive(Default)] pub(crate) struct Interner(Lock); // The `&'static str`s in this type actually point into the arena. // // The `FxHashMap`+`Vec` pair could be replaced by `FxIndexSet`, but #75278 // found that to regress performance up to 2% in some cases. This might be // revisited after further improvements to `indexmap`. // // This type is private to prevent accidentally constructing more than one // `Interner` on the same thread, which makes it easy to mix up `Symbol`s // between `Interner`s. #[derive(Default)] struct InternerInner { arena: DroplessArena, names: FxHashMap<&'static str, Symbol>, strings: Vec<&'static str>, } impl Interner { fn prefill(init: &[&'static str]) -> Self { Interner(Lock::new(InternerInner { strings: init.into(), names: init.iter().copied().zip((0..).map(Symbol::new)).collect(), ..Default::default() })) } #[inline] fn intern(&self, string: &str) -> Symbol { let mut inner = self.0.lock(); if let Some(&name) = inner.names.get(string) { return name; } let name = Symbol::new(inner.strings.len() as u32); // SAFETY: we convert from `&str` to `&[u8]`, clone it into the arena, // and immediately convert the clone back to `&[u8], all because there // is no `inner.arena.alloc_str()` method. This is clearly safe. let string: &str = unsafe { str::from_utf8_unchecked(inner.arena.alloc_slice(string.as_bytes())) }; // SAFETY: we can extend the arena allocation to `'static` because we // only access these while the arena is still alive. let string: &'static str = unsafe { &*(string as *const str) }; inner.strings.push(string); // This second hash table lookup can be avoided by using `RawEntryMut`, // but this code path isn't hot enough for it to be worth it. See // #91445 for details. inner.names.insert(string, name); name } // Get the symbol as a string. `Symbol::as_str()` should be used in // preference to this function. fn get(&self, symbol: Symbol) -> &str { self.0.lock().strings[symbol.0.as_usize()] } } // This module has a very short name because it's used a lot. /// This module contains all the defined keyword `Symbol`s. /// /// Given that `kw` is imported, use them like `kw::keyword_name`. /// For example `kw::Loop` or `kw::Break`. pub mod kw { pub use super::kw_generated::*; } // This module has a very short name because it's used a lot. /// This module contains all the defined non-keyword `Symbol`s. /// /// Given that `sym` is imported, use them like `sym::symbol_name`. /// For example `sym::rustfmt` or `sym::u8`. pub mod sym { use super::Symbol; use std::convert::TryInto; #[doc(inline)] pub use super::sym_generated::*; // Used from a macro in `librustc_feature/accepted.rs` pub use super::kw::MacroRules as macro_rules; /// Get the symbol for an integer. /// /// The first few non-negative integers each have a static symbol and therefore /// are fast. pub fn integer + Copy + ToString>(n: N) -> Symbol { if let Result::Ok(idx) = n.try_into() { if idx < 10 { return Symbol::new(super::SYMBOL_DIGITS_BASE + idx as u32); } } Symbol::intern(&n.to_string()) } } impl Symbol { fn is_special(self) -> bool { self <= kw::Underscore } fn is_used_keyword_always(self) -> bool { self >= kw::As && self <= kw::While } fn is_used_keyword_conditional(self, edition: impl FnOnce() -> Edition) -> bool { (self >= kw::Async && self <= kw::Dyn) && edition() >= Edition::Edition2018 } fn is_unused_keyword_always(self) -> bool { self >= kw::Abstract && self <= kw::Yield } fn is_unused_keyword_conditional(self, edition: impl FnOnce() -> Edition) -> bool { self == kw::Try && edition() >= Edition::Edition2018 } pub fn is_reserved(self, edition: impl Copy + FnOnce() -> Edition) -> bool { self.is_special() || self.is_used_keyword_always() || self.is_unused_keyword_always() || self.is_used_keyword_conditional(edition) || self.is_unused_keyword_conditional(edition) } /// A keyword or reserved identifier that can be used as a path segment. pub fn is_path_segment_keyword(self) -> bool { self == kw::Super || self == kw::SelfLower || self == kw::SelfUpper || self == kw::Crate || self == kw::PathRoot || self == kw::DollarCrate } /// Returns `true` if the symbol is `true` or `false`. pub fn is_bool_lit(self) -> bool { self == kw::True || self == kw::False } /// Returns `true` if this symbol can be a raw identifier. pub fn can_be_raw(self) -> bool { self != kw::Empty && self != kw::Underscore && !self.is_path_segment_keyword() } } impl Ident { // Returns `true` for reserved identifiers used internally for elided lifetimes, // unnamed method parameters, crate root module, error recovery etc. pub fn is_special(self) -> bool { self.name.is_special() } /// Returns `true` if the token is a keyword used in the language. pub fn is_used_keyword(self) -> bool { // Note: `span.edition()` is relatively expensive, don't call it unless necessary. self.name.is_used_keyword_always() || self.name.is_used_keyword_conditional(|| self.span.edition()) } /// Returns `true` if the token is a keyword reserved for possible future use. pub fn is_unused_keyword(self) -> bool { // Note: `span.edition()` is relatively expensive, don't call it unless necessary. self.name.is_unused_keyword_always() || self.name.is_unused_keyword_conditional(|| self.span.edition()) } /// Returns `true` if the token is either a special identifier or a keyword. pub fn is_reserved(self) -> bool { // Note: `span.edition()` is relatively expensive, don't call it unless necessary. self.name.is_reserved(|| self.span.edition()) } /// A keyword or reserved identifier that can be used as a path segment. pub fn is_path_segment_keyword(self) -> bool { self.name.is_path_segment_keyword() } /// We see this identifier in a normal identifier position, like variable name or a type. /// How was it written originally? Did it use the raw form? Let's try to guess. pub fn is_raw_guess(self) -> bool { self.name.can_be_raw() && self.is_reserved() } }