mirror of
https://github.com/rust-lang/rust.git
synced 2025-12-01 01:28:29 +00:00
f5a143f796
Ergonomic ref counting This is an experimental first version of ergonomic ref counting. This first version implements most of the RFC but doesn't implement any of the optimizations. This was left for following iterations. RFC: https://github.com/rust-lang/rfcs/pull/3680 Tracking issue: https://github.com/rust-lang/rust/issues/132290 Project goal: https://github.com/rust-lang/rust-project-goals/issues/107 r? ```@nikomatsakis```
506 lines
36 KiB
Rust
506 lines
36 KiB
Rust
//! Defines lang items.
|
|
//!
|
|
//! Language items are items that represent concepts intrinsic to the language
|
|
//! itself. Examples are:
|
|
//!
|
|
//! * Traits that specify "kinds"; e.g., `Sync`, `Send`.
|
|
//! * Traits that represent operators; e.g., `Add`, `Sub`, `Index`.
|
|
//! * Functions called by the compiler itself.
|
|
|
|
use rustc_ast::attr::AttributeExt;
|
|
use rustc_data_structures::fx::FxIndexMap;
|
|
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
|
|
use rustc_macros::{Decodable, Encodable, HashStable_Generic};
|
|
use rustc_span::{Span, Symbol, kw, sym};
|
|
|
|
use crate::def_id::DefId;
|
|
use crate::{MethodKind, Target};
|
|
|
|
/// All of the lang items, defined or not.
|
|
/// Defined lang items can come from the current crate or its dependencies.
|
|
#[derive(HashStable_Generic, Debug)]
|
|
pub struct LanguageItems {
|
|
/// Mappings from lang items to their possibly found [`DefId`]s.
|
|
/// The index corresponds to the order in [`LangItem`].
|
|
items: [Option<DefId>; std::mem::variant_count::<LangItem>()],
|
|
reverse_items: FxIndexMap<DefId, LangItem>,
|
|
/// Lang items that were not found during collection.
|
|
pub missing: Vec<LangItem>,
|
|
}
|
|
|
|
impl LanguageItems {
|
|
/// Construct an empty collection of lang items and no missing ones.
|
|
pub fn new() -> Self {
|
|
Self {
|
|
items: [None; std::mem::variant_count::<LangItem>()],
|
|
reverse_items: FxIndexMap::default(),
|
|
missing: Vec::new(),
|
|
}
|
|
}
|
|
|
|
pub fn get(&self, item: LangItem) -> Option<DefId> {
|
|
self.items[item as usize]
|
|
}
|
|
|
|
pub fn set(&mut self, item: LangItem, def_id: DefId) {
|
|
self.items[item as usize] = Some(def_id);
|
|
let preexisting = self.reverse_items.insert(def_id, item);
|
|
|
|
// This needs to be a bijection.
|
|
if let Some(preexisting) = preexisting {
|
|
panic!(
|
|
"For the bijection of LangItem <=> DefId to work,\
|
|
one item DefId may only be assigned one LangItem. \
|
|
Separate the LangItem definitions for {item:?} and {preexisting:?}."
|
|
);
|
|
}
|
|
}
|
|
|
|
pub fn from_def_id(&self, def_id: DefId) -> Option<LangItem> {
|
|
self.reverse_items.get(&def_id).copied()
|
|
}
|
|
|
|
pub fn iter(&self) -> impl Iterator<Item = (LangItem, DefId)> {
|
|
self.items
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(i, id)| id.map(|id| (LangItem::from_u32(i as u32).unwrap(), id)))
|
|
}
|
|
}
|
|
|
|
// The actual lang items defined come at the end of this file in one handy table.
|
|
// So you probably just want to nip down to the end.
|
|
macro_rules! language_item_table {
|
|
(
|
|
$( $(#[$attr:meta])* $variant:ident, $module:ident :: $name:ident, $method:ident, $target:expr, $generics:expr; )*
|
|
) => {
|
|
/// A representation of all the valid lang items in Rust.
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable)]
|
|
pub enum LangItem {
|
|
$(
|
|
#[doc = concat!("The `", stringify!($name), "` lang item.")]
|
|
$(#[$attr])*
|
|
$variant,
|
|
)*
|
|
}
|
|
|
|
impl LangItem {
|
|
fn from_u32(u: u32) -> Option<LangItem> {
|
|
// This implementation is clumsy, but makes no assumptions
|
|
// about how discriminant tags are allocated within the
|
|
// range `0 .. std::mem::variant_count::<LangItem>()`.
|
|
$(if u == LangItem::$variant as u32 {
|
|
return Some(LangItem::$variant)
|
|
})*
|
|
None
|
|
}
|
|
|
|
/// Returns the `name` symbol in `#[lang = "$name"]`.
|
|
/// For example, [`LangItem::PartialEq`]`.name()`
|
|
/// would result in [`sym::eq`] since it is `#[lang = "eq"]`.
|
|
pub fn name(self) -> Symbol {
|
|
match self {
|
|
$( LangItem::$variant => $module::$name, )*
|
|
}
|
|
}
|
|
|
|
/// Opposite of [`LangItem::name`]
|
|
pub fn from_name(name: Symbol) -> Option<Self> {
|
|
match name {
|
|
$( $module::$name => Some(LangItem::$variant), )*
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// Returns the name of the `LangItem` enum variant.
|
|
// This method is used by Clippy for internal lints.
|
|
pub fn variant_name(self) -> &'static str {
|
|
match self {
|
|
$( LangItem::$variant => stringify!($variant), )*
|
|
}
|
|
}
|
|
|
|
pub fn target(self) -> Target {
|
|
match self {
|
|
$( LangItem::$variant => $target, )*
|
|
}
|
|
}
|
|
|
|
pub fn required_generics(&self) -> GenericRequirement {
|
|
match self {
|
|
$( LangItem::$variant => $generics, )*
|
|
}
|
|
}
|
|
}
|
|
|
|
impl LanguageItems {
|
|
$(
|
|
#[doc = concat!("Returns the [`DefId`] of the `", stringify!($name), "` lang item if it is defined.")]
|
|
pub fn $method(&self) -> Option<DefId> {
|
|
self.items[LangItem::$variant as usize]
|
|
}
|
|
)*
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<CTX> HashStable<CTX> for LangItem {
|
|
fn hash_stable(&self, _: &mut CTX, hasher: &mut StableHasher) {
|
|
::std::hash::Hash::hash(self, hasher);
|
|
}
|
|
}
|
|
|
|
/// Extracts the first `lang = "$name"` out of a list of attributes.
|
|
/// The `#[panic_handler]` attribute is also extracted out when found.
|
|
pub fn extract(attrs: &[impl AttributeExt]) -> Option<(Symbol, Span)> {
|
|
attrs.iter().find_map(|attr| {
|
|
Some(match attr {
|
|
_ if attr.has_name(sym::lang) => (attr.value_str()?, attr.span()),
|
|
_ if attr.has_name(sym::panic_handler) => (sym::panic_impl, attr.span()),
|
|
_ => return None,
|
|
})
|
|
})
|
|
}
|
|
|
|
language_item_table! {
|
|
// Variant name, Name, Getter method name, Target Generic requirements;
|
|
Sized, sym::sized, sized_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
Unsize, sym::unsize, unsize_trait, Target::Trait, GenericRequirement::Minimum(1);
|
|
/// Trait injected by `#[derive(PartialEq)]`, (i.e. "Partial EQ").
|
|
StructuralPeq, sym::structural_peq, structural_peq_trait, Target::Trait, GenericRequirement::None;
|
|
Copy, sym::copy, copy_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
Clone, sym::clone, clone_trait, Target::Trait, GenericRequirement::None;
|
|
CloneFn, sym::clone_fn, clone_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
|
|
UseCloned, sym::use_cloned, use_cloned_trait, Target::Trait, GenericRequirement::None;
|
|
Sync, sym::sync, sync_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
DiscriminantKind, sym::discriminant_kind, discriminant_kind_trait, Target::Trait, GenericRequirement::None;
|
|
/// The associated item of the `DiscriminantKind` trait.
|
|
Discriminant, sym::discriminant_type, discriminant_type, Target::AssocTy, GenericRequirement::None;
|
|
|
|
PointeeTrait, sym::pointee_trait, pointee_trait, Target::Trait, GenericRequirement::None;
|
|
Metadata, sym::metadata_type, metadata_type, Target::AssocTy, GenericRequirement::None;
|
|
DynMetadata, sym::dyn_metadata, dyn_metadata, Target::Struct, GenericRequirement::None;
|
|
|
|
Freeze, sym::freeze, freeze_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
|
|
FnPtrTrait, sym::fn_ptr_trait, fn_ptr_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
FnPtrAddr, sym::fn_ptr_addr, fn_ptr_addr, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
|
|
|
|
Drop, sym::drop, drop_trait, Target::Trait, GenericRequirement::None;
|
|
Destruct, sym::destruct, destruct_trait, Target::Trait, GenericRequirement::None;
|
|
|
|
AsyncDrop, sym::async_drop, async_drop_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
AsyncDestruct, sym::async_destruct, async_destruct_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
AsyncDropInPlace, sym::async_drop_in_place, async_drop_in_place_fn, Target::Fn, GenericRequirement::Exact(1);
|
|
SurfaceAsyncDropInPlace, sym::surface_async_drop_in_place, surface_async_drop_in_place_fn, Target::Fn, GenericRequirement::Exact(1);
|
|
AsyncDropSurfaceDropInPlace, sym::async_drop_surface_drop_in_place, async_drop_surface_drop_in_place_fn, Target::Fn, GenericRequirement::Exact(1);
|
|
AsyncDropSlice, sym::async_drop_slice, async_drop_slice_fn, Target::Fn, GenericRequirement::Exact(1);
|
|
AsyncDropChain, sym::async_drop_chain, async_drop_chain_fn, Target::Fn, GenericRequirement::Exact(2);
|
|
AsyncDropNoop, sym::async_drop_noop, async_drop_noop_fn, Target::Fn, GenericRequirement::Exact(0);
|
|
AsyncDropDeferredDropInPlace, sym::async_drop_deferred_drop_in_place, async_drop_deferred_drop_in_place_fn, Target::Fn, GenericRequirement::Exact(1);
|
|
AsyncDropFuse, sym::async_drop_fuse, async_drop_fuse_fn, Target::Fn, GenericRequirement::Exact(1);
|
|
AsyncDropDefer, sym::async_drop_defer, async_drop_defer_fn, Target::Fn, GenericRequirement::Exact(1);
|
|
AsyncDropEither, sym::async_drop_either, async_drop_either_fn, Target::Fn, GenericRequirement::Exact(3);
|
|
|
|
CoerceUnsized, sym::coerce_unsized, coerce_unsized_trait, Target::Trait, GenericRequirement::Minimum(1);
|
|
DispatchFromDyn, sym::dispatch_from_dyn, dispatch_from_dyn_trait, Target::Trait, GenericRequirement::Minimum(1);
|
|
|
|
// lang items relating to transmutability
|
|
TransmuteOpts, sym::transmute_opts, transmute_opts, Target::Struct, GenericRequirement::Exact(0);
|
|
TransmuteTrait, sym::transmute_trait, transmute_trait, Target::Trait, GenericRequirement::Exact(2);
|
|
|
|
Add, sym::add, add_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
Sub, sym::sub, sub_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
Mul, sym::mul, mul_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
Div, sym::div, div_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
Rem, sym::rem, rem_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
Neg, sym::neg, neg_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
Not, sym::not, not_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
BitXor, sym::bitxor, bitxor_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
BitAnd, sym::bitand, bitand_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
BitOr, sym::bitor, bitor_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
Shl, sym::shl, shl_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
Shr, sym::shr, shr_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
AddAssign, sym::add_assign, add_assign_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
SubAssign, sym::sub_assign, sub_assign_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
MulAssign, sym::mul_assign, mul_assign_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
DivAssign, sym::div_assign, div_assign_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
RemAssign, sym::rem_assign, rem_assign_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
BitXorAssign, sym::bitxor_assign, bitxor_assign_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
BitAndAssign, sym::bitand_assign, bitand_assign_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
BitOrAssign, sym::bitor_assign, bitor_assign_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
ShlAssign, sym::shl_assign, shl_assign_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
ShrAssign, sym::shr_assign, shr_assign_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
Index, sym::index, index_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
IndexMut, sym::index_mut, index_mut_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
|
|
UnsafeCell, sym::unsafe_cell, unsafe_cell_type, Target::Struct, GenericRequirement::None;
|
|
VaList, sym::va_list, va_list, Target::Struct, GenericRequirement::None;
|
|
|
|
Deref, sym::deref, deref_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
DerefMut, sym::deref_mut, deref_mut_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
DerefPure, sym::deref_pure, deref_pure_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
DerefTarget, sym::deref_target, deref_target, Target::AssocTy, GenericRequirement::None;
|
|
Receiver, sym::receiver, receiver_trait, Target::Trait, GenericRequirement::None;
|
|
ReceiverTarget, sym::receiver_target, receiver_target, Target::AssocTy, GenericRequirement::None;
|
|
LegacyReceiver, sym::legacy_receiver, legacy_receiver_trait, Target::Trait, GenericRequirement::None;
|
|
|
|
Fn, kw::Fn, fn_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
FnMut, sym::fn_mut, fn_mut_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
FnOnce, sym::fn_once, fn_once_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
|
|
AsyncFn, sym::async_fn, async_fn_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
AsyncFnMut, sym::async_fn_mut, async_fn_mut_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
AsyncFnOnce, sym::async_fn_once, async_fn_once_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
AsyncFnOnceOutput, sym::async_fn_once_output, async_fn_once_output, Target::AssocTy, GenericRequirement::Exact(1);
|
|
CallOnceFuture, sym::call_once_future, call_once_future, Target::AssocTy, GenericRequirement::Exact(1);
|
|
CallRefFuture, sym::call_ref_future, call_ref_future, Target::AssocTy, GenericRequirement::Exact(2);
|
|
AsyncFnKindHelper, sym::async_fn_kind_helper, async_fn_kind_helper, Target::Trait, GenericRequirement::Exact(1);
|
|
AsyncFnKindUpvars, sym::async_fn_kind_upvars, async_fn_kind_upvars, Target::AssocTy, GenericRequirement::Exact(5);
|
|
|
|
FnOnceOutput, sym::fn_once_output, fn_once_output, Target::AssocTy, GenericRequirement::None;
|
|
|
|
Iterator, sym::iterator, iterator_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
FusedIterator, sym::fused_iterator, fused_iterator_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
Future, sym::future_trait, future_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
FutureOutput, sym::future_output, future_output, Target::AssocTy, GenericRequirement::Exact(0);
|
|
AsyncIterator, sym::async_iterator, async_iterator_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
|
|
CoroutineState, sym::coroutine_state, coroutine_state, Target::Enum, GenericRequirement::None;
|
|
Coroutine, sym::coroutine, coroutine_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
CoroutineReturn, sym::coroutine_return, coroutine_return, Target::AssocTy, GenericRequirement::Exact(1);
|
|
CoroutineYield, sym::coroutine_yield, coroutine_yield, Target::AssocTy, GenericRequirement::Exact(1);
|
|
CoroutineResume, sym::coroutine_resume, coroutine_resume, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
|
|
|
|
Unpin, sym::unpin, unpin_trait, Target::Trait, GenericRequirement::None;
|
|
Pin, sym::pin, pin_type, Target::Struct, GenericRequirement::None;
|
|
|
|
OrderingEnum, sym::Ordering, ordering_enum, Target::Enum, GenericRequirement::Exact(0);
|
|
PartialEq, sym::eq, eq_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
PartialOrd, sym::partial_ord, partial_ord_trait, Target::Trait, GenericRequirement::Exact(1);
|
|
CVoid, sym::c_void, c_void, Target::Enum, GenericRequirement::None;
|
|
|
|
// A number of panic-related lang items. The `panic` item corresponds to divide-by-zero and
|
|
// various panic cases with `match`. The `panic_bounds_check` item is for indexing arrays.
|
|
//
|
|
// The `begin_unwind` lang item has a predefined symbol name and is sort of a "weak lang item"
|
|
// in the sense that a crate is not required to have it defined to use it, but a final product
|
|
// is required to define it somewhere. Additionally, there are restrictions on crates that use
|
|
// a weak lang item, but do not have it defined.
|
|
Panic, sym::panic, panic_fn, Target::Fn, GenericRequirement::Exact(0);
|
|
PanicNounwind, sym::panic_nounwind, panic_nounwind, Target::Fn, GenericRequirement::Exact(0);
|
|
PanicFmt, sym::panic_fmt, panic_fmt, Target::Fn, GenericRequirement::None;
|
|
ConstPanicFmt, sym::const_panic_fmt, const_panic_fmt, Target::Fn, GenericRequirement::None;
|
|
PanicBoundsCheck, sym::panic_bounds_check, panic_bounds_check_fn, Target::Fn, GenericRequirement::Exact(0);
|
|
PanicMisalignedPointerDereference, sym::panic_misaligned_pointer_dereference, panic_misaligned_pointer_dereference_fn, Target::Fn, GenericRequirement::Exact(0);
|
|
PanicInfo, sym::panic_info, panic_info, Target::Struct, GenericRequirement::None;
|
|
PanicLocation, sym::panic_location, panic_location, Target::Struct, GenericRequirement::None;
|
|
PanicImpl, sym::panic_impl, panic_impl, Target::Fn, GenericRequirement::None;
|
|
PanicCannotUnwind, sym::panic_cannot_unwind, panic_cannot_unwind, Target::Fn, GenericRequirement::Exact(0);
|
|
PanicInCleanup, sym::panic_in_cleanup, panic_in_cleanup, Target::Fn, GenericRequirement::Exact(0);
|
|
/// Constant panic messages, used for codegen of MIR asserts.
|
|
PanicAddOverflow, sym::panic_const_add_overflow, panic_const_add_overflow, Target::Fn, GenericRequirement::None;
|
|
PanicSubOverflow, sym::panic_const_sub_overflow, panic_const_sub_overflow, Target::Fn, GenericRequirement::None;
|
|
PanicMulOverflow, sym::panic_const_mul_overflow, panic_const_mul_overflow, Target::Fn, GenericRequirement::None;
|
|
PanicDivOverflow, sym::panic_const_div_overflow, panic_const_div_overflow, Target::Fn, GenericRequirement::None;
|
|
PanicRemOverflow, sym::panic_const_rem_overflow, panic_const_rem_overflow, Target::Fn, GenericRequirement::None;
|
|
PanicNegOverflow, sym::panic_const_neg_overflow, panic_const_neg_overflow, Target::Fn, GenericRequirement::None;
|
|
PanicShrOverflow, sym::panic_const_shr_overflow, panic_const_shr_overflow, Target::Fn, GenericRequirement::None;
|
|
PanicShlOverflow, sym::panic_const_shl_overflow, panic_const_shl_overflow, Target::Fn, GenericRequirement::None;
|
|
PanicDivZero, sym::panic_const_div_by_zero, panic_const_div_by_zero, Target::Fn, GenericRequirement::None;
|
|
PanicRemZero, sym::panic_const_rem_by_zero, panic_const_rem_by_zero, Target::Fn, GenericRequirement::None;
|
|
PanicCoroutineResumed, sym::panic_const_coroutine_resumed, panic_const_coroutine_resumed, Target::Fn, GenericRequirement::None;
|
|
PanicAsyncFnResumed, sym::panic_const_async_fn_resumed, panic_const_async_fn_resumed, Target::Fn, GenericRequirement::None;
|
|
PanicAsyncGenFnResumed, sym::panic_const_async_gen_fn_resumed, panic_const_async_gen_fn_resumed, Target::Fn, GenericRequirement::None;
|
|
PanicGenFnNone, sym::panic_const_gen_fn_none, panic_const_gen_fn_none, Target::Fn, GenericRequirement::None;
|
|
PanicCoroutineResumedPanic, sym::panic_const_coroutine_resumed_panic, panic_const_coroutine_resumed_panic, Target::Fn, GenericRequirement::None;
|
|
PanicAsyncFnResumedPanic, sym::panic_const_async_fn_resumed_panic, panic_const_async_fn_resumed_panic, Target::Fn, GenericRequirement::None;
|
|
PanicAsyncGenFnResumedPanic, sym::panic_const_async_gen_fn_resumed_panic, panic_const_async_gen_fn_resumed_panic, Target::Fn, GenericRequirement::None;
|
|
PanicGenFnNonePanic, sym::panic_const_gen_fn_none_panic, panic_const_gen_fn_none_panic, Target::Fn, GenericRequirement::None;
|
|
PanicNullPointerDereference, sym::panic_null_pointer_dereference, panic_null_pointer_dereference, Target::Fn, GenericRequirement::None;
|
|
/// libstd panic entry point. Necessary for const eval to be able to catch it
|
|
BeginPanic, sym::begin_panic, begin_panic_fn, Target::Fn, GenericRequirement::None;
|
|
|
|
// Lang items needed for `format_args!()`.
|
|
FormatAlignment, sym::format_alignment, format_alignment, Target::Enum, GenericRequirement::None;
|
|
FormatArgument, sym::format_argument, format_argument, Target::Struct, GenericRequirement::None;
|
|
FormatArguments, sym::format_arguments, format_arguments, Target::Struct, GenericRequirement::None;
|
|
FormatCount, sym::format_count, format_count, Target::Enum, GenericRequirement::None;
|
|
FormatPlaceholder, sym::format_placeholder, format_placeholder, Target::Struct, GenericRequirement::None;
|
|
FormatUnsafeArg, sym::format_unsafe_arg, format_unsafe_arg, Target::Struct, GenericRequirement::None;
|
|
|
|
ExchangeMalloc, sym::exchange_malloc, exchange_malloc_fn, Target::Fn, GenericRequirement::None;
|
|
DropInPlace, sym::drop_in_place, drop_in_place_fn, Target::Fn, GenericRequirement::Minimum(1);
|
|
FallbackSurfaceDrop, sym::fallback_surface_drop, fallback_surface_drop_fn, Target::Fn, GenericRequirement::None;
|
|
AllocLayout, sym::alloc_layout, alloc_layout, Target::Struct, GenericRequirement::None;
|
|
|
|
/// For all binary crates without `#![no_main]`, Rust will generate a "main" function.
|
|
/// The exact name and signature are target-dependent. The "main" function will invoke
|
|
/// this lang item, passing it the `argc` and `argv` (or null, if those don't exist
|
|
/// on the current target) as well as the user-defined `fn main` from the binary crate.
|
|
Start, sym::start, start_fn, Target::Fn, GenericRequirement::Exact(1);
|
|
|
|
EhPersonality, sym::eh_personality, eh_personality, Target::Fn, GenericRequirement::None;
|
|
EhCatchTypeinfo, sym::eh_catch_typeinfo, eh_catch_typeinfo, Target::Static, GenericRequirement::None;
|
|
|
|
OwnedBox, sym::owned_box, owned_box, Target::Struct, GenericRequirement::Minimum(1);
|
|
GlobalAlloc, sym::global_alloc_ty, global_alloc_ty, Target::Struct, GenericRequirement::None;
|
|
|
|
// Experimental lang item for Miri
|
|
PtrUnique, sym::ptr_unique, ptr_unique, Target::Struct, GenericRequirement::Exact(1);
|
|
|
|
PhantomData, sym::phantom_data, phantom_data, Target::Struct, GenericRequirement::Exact(1);
|
|
|
|
ManuallyDrop, sym::manually_drop, manually_drop, Target::Struct, GenericRequirement::None;
|
|
BikeshedGuaranteedNoDrop, sym::bikeshed_guaranteed_no_drop, bikeshed_guaranteed_no_drop, Target::Trait, GenericRequirement::Exact(0);
|
|
|
|
MaybeUninit, sym::maybe_uninit, maybe_uninit, Target::Union, GenericRequirement::None;
|
|
|
|
Termination, sym::termination, termination, Target::Trait, GenericRequirement::None;
|
|
|
|
Try, sym::Try, try_trait, Target::Trait, GenericRequirement::None;
|
|
|
|
Tuple, sym::tuple_trait, tuple_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
|
|
SliceLen, sym::slice_len_fn, slice_len_fn, Target::Method(MethodKind::Inherent), GenericRequirement::None;
|
|
|
|
// Language items from AST lowering
|
|
TryTraitFromResidual, sym::from_residual, from_residual_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
|
|
TryTraitFromOutput, sym::from_output, from_output_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
|
|
TryTraitBranch, sym::branch, branch_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
|
|
TryTraitFromYeet, sym::from_yeet, from_yeet_fn, Target::Fn, GenericRequirement::None;
|
|
|
|
PointerLike, sym::pointer_like, pointer_like, Target::Trait, GenericRequirement::Exact(0);
|
|
|
|
CoercePointeeValidated, sym::coerce_pointee_validated, coerce_pointee_validated_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
|
|
ConstParamTy, sym::const_param_ty, const_param_ty_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
UnsizedConstParamTy, sym::unsized_const_param_ty, unsized_const_param_ty_trait, Target::Trait, GenericRequirement::Exact(0);
|
|
|
|
Poll, sym::Poll, poll, Target::Enum, GenericRequirement::None;
|
|
PollReady, sym::Ready, poll_ready_variant, Target::Variant, GenericRequirement::None;
|
|
PollPending, sym::Pending, poll_pending_variant, Target::Variant, GenericRequirement::None;
|
|
|
|
AsyncGenReady, sym::AsyncGenReady, async_gen_ready, Target::Method(MethodKind::Inherent), GenericRequirement::Exact(1);
|
|
AsyncGenPending, sym::AsyncGenPending, async_gen_pending, Target::AssocConst, GenericRequirement::Exact(1);
|
|
AsyncGenFinished, sym::AsyncGenFinished, async_gen_finished, Target::AssocConst, GenericRequirement::Exact(1);
|
|
|
|
// FIXME(swatinem): the following lang items are used for async lowering and
|
|
// should become obsolete eventually.
|
|
ResumeTy, sym::ResumeTy, resume_ty, Target::Struct, GenericRequirement::None;
|
|
GetContext, sym::get_context, get_context_fn, Target::Fn, GenericRequirement::None;
|
|
|
|
Context, sym::Context, context, Target::Struct, GenericRequirement::None;
|
|
FuturePoll, sym::poll, future_poll_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
|
|
|
|
AsyncIteratorPollNext, sym::async_iterator_poll_next, async_iterator_poll_next, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::Exact(0);
|
|
IntoAsyncIterIntoIter, sym::into_async_iter_into_iter, into_async_iter_into_iter, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::Exact(0);
|
|
|
|
Option, sym::Option, option_type, Target::Enum, GenericRequirement::None;
|
|
OptionSome, sym::Some, option_some_variant, Target::Variant, GenericRequirement::None;
|
|
OptionNone, sym::None, option_none_variant, Target::Variant, GenericRequirement::None;
|
|
|
|
ResultOk, sym::Ok, result_ok_variant, Target::Variant, GenericRequirement::None;
|
|
ResultErr, sym::Err, result_err_variant, Target::Variant, GenericRequirement::None;
|
|
|
|
ControlFlowContinue, sym::Continue, cf_continue_variant, Target::Variant, GenericRequirement::None;
|
|
ControlFlowBreak, sym::Break, cf_break_variant, Target::Variant, GenericRequirement::None;
|
|
|
|
IntoFutureIntoFuture, sym::into_future, into_future_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
|
|
IntoIterIntoIter, sym::into_iter, into_iter_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
|
|
IteratorNext, sym::next, next_fn, Target::Method(MethodKind::Trait { body: false}), GenericRequirement::None;
|
|
|
|
PinNewUnchecked, sym::new_unchecked, new_unchecked_fn, Target::Method(MethodKind::Inherent), GenericRequirement::None;
|
|
|
|
RangeFrom, sym::RangeFrom, range_from_struct, Target::Struct, GenericRequirement::None;
|
|
RangeFull, sym::RangeFull, range_full_struct, Target::Struct, GenericRequirement::None;
|
|
RangeInclusiveStruct, sym::RangeInclusive, range_inclusive_struct, Target::Struct, GenericRequirement::None;
|
|
RangeInclusiveNew, sym::range_inclusive_new, range_inclusive_new_method, Target::Method(MethodKind::Inherent), GenericRequirement::None;
|
|
Range, sym::Range, range_struct, Target::Struct, GenericRequirement::None;
|
|
RangeToInclusive, sym::RangeToInclusive, range_to_inclusive_struct, Target::Struct, GenericRequirement::None;
|
|
RangeTo, sym::RangeTo, range_to_struct, Target::Struct, GenericRequirement::None;
|
|
RangeMax, sym::RangeMax, range_max, Target::AssocConst, GenericRequirement::Exact(0);
|
|
RangeMin, sym::RangeMin, range_min, Target::AssocConst, GenericRequirement::Exact(0);
|
|
RangeSub, sym::RangeSub, range_sub, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::Exact(0);
|
|
|
|
// `new_range` types that are `Copy + IntoIterator`
|
|
RangeFromCopy, sym::RangeFromCopy, range_from_copy_struct, Target::Struct, GenericRequirement::None;
|
|
RangeCopy, sym::RangeCopy, range_copy_struct, Target::Struct, GenericRequirement::None;
|
|
RangeInclusiveCopy, sym::RangeInclusiveCopy, range_inclusive_copy_struct, Target::Struct, GenericRequirement::None;
|
|
|
|
String, sym::String, string, Target::Struct, GenericRequirement::None;
|
|
CStr, sym::CStr, c_str, Target::Struct, GenericRequirement::None;
|
|
|
|
// Experimental lang items for implementing contract pre- and post-condition checking.
|
|
ContractBuildCheckEnsures, sym::contract_build_check_ensures, contract_build_check_ensures_fn, Target::Fn, GenericRequirement::None;
|
|
ContractCheckRequires, sym::contract_check_requires, contract_check_requires_fn, Target::Fn, GenericRequirement::None;
|
|
}
|
|
|
|
/// The requirement imposed on the generics of a lang item
|
|
pub enum GenericRequirement {
|
|
/// No restriction on the generics
|
|
None,
|
|
/// A minimum number of generics that is demanded on a lang item
|
|
Minimum(usize),
|
|
/// The number of generics must match precisely as stipulated
|
|
Exact(usize),
|
|
}
|
|
|
|
pub static FN_TRAITS: &'static [LangItem] = &[LangItem::Fn, LangItem::FnMut, LangItem::FnOnce];
|
|
|
|
pub static OPERATORS: &'static [LangItem] = &[
|
|
LangItem::Add,
|
|
LangItem::Sub,
|
|
LangItem::Mul,
|
|
LangItem::Div,
|
|
LangItem::Rem,
|
|
LangItem::Neg,
|
|
LangItem::Not,
|
|
LangItem::BitXor,
|
|
LangItem::BitAnd,
|
|
LangItem::BitOr,
|
|
LangItem::Shl,
|
|
LangItem::Shr,
|
|
LangItem::AddAssign,
|
|
LangItem::SubAssign,
|
|
LangItem::MulAssign,
|
|
LangItem::DivAssign,
|
|
LangItem::RemAssign,
|
|
LangItem::BitXorAssign,
|
|
LangItem::BitAndAssign,
|
|
LangItem::BitOrAssign,
|
|
LangItem::ShlAssign,
|
|
LangItem::ShrAssign,
|
|
LangItem::Index,
|
|
LangItem::IndexMut,
|
|
LangItem::PartialEq,
|
|
LangItem::PartialOrd,
|
|
];
|
|
|
|
pub static BINARY_OPERATORS: &'static [LangItem] = &[
|
|
LangItem::Add,
|
|
LangItem::Sub,
|
|
LangItem::Mul,
|
|
LangItem::Div,
|
|
LangItem::Rem,
|
|
LangItem::BitXor,
|
|
LangItem::BitAnd,
|
|
LangItem::BitOr,
|
|
LangItem::Shl,
|
|
LangItem::Shr,
|
|
LangItem::AddAssign,
|
|
LangItem::SubAssign,
|
|
LangItem::MulAssign,
|
|
LangItem::DivAssign,
|
|
LangItem::RemAssign,
|
|
LangItem::BitXorAssign,
|
|
LangItem::BitAndAssign,
|
|
LangItem::BitOrAssign,
|
|
LangItem::ShlAssign,
|
|
LangItem::ShrAssign,
|
|
LangItem::Index,
|
|
LangItem::IndexMut,
|
|
LangItem::PartialEq,
|
|
LangItem::PartialOrd,
|
|
];
|