pub use self::BorrowKind::*;
pub use self::IntVarValue::*;
pub use self::Variance::*;
+pub use adt::*;
pub use assoc::*;
+pub use closure::*;
pub use generics::*;
-pub use upvar::*;
use crate::hir::exports::ExportMap;
use crate::hir::place::{
};
use crate::ich::StableHashingContext;
use crate::middle::cstore::CrateStoreDyn;
-use crate::mir::interpret::ErrorHandled;
use crate::mir::{Body, GeneratorLayout};
use crate::traits::{self, Reveal};
use crate::ty;
use crate::ty::subst::{GenericArg, InternalSubsts, Subst, SubstsRef};
-use crate::ty::util::{Discr, IntTypeExt};
+use crate::ty::util::Discr;
use rustc_ast as ast;
use rustc_attr as attr;
use rustc_data_structures::captures::Captures;
-use rustc_data_structures::fingerprint::Fingerprint;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::sync::{self, par_iter, ParallelIterator};
use rustc_data_structures::tagged_ptr::CopyTaggedPtr;
-use rustc_errors::ErrorReported;
use rustc_hir as hir;
use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, CRATE_DEF_INDEX};
-use rustc_hir::lang_items::LangItem;
use rustc_hir::{Constness, Node};
-use rustc_index::vec::{Idx, IndexVec};
use rustc_macros::HashStable;
-use rustc_serialize::{self, Encodable, Encoder};
-use rustc_session::DataTypeKind;
use rustc_span::hygiene::ExpnId;
-use rustc_span::symbol::{kw, sym, Ident, Symbol};
+use rustc_span::symbol::{kw, Ident, Symbol};
use rustc_span::Span;
-use rustc_target::abi::{Align, VariantIdx};
+use rustc_target::abi::Align;
-use std::cell::RefCell;
use std::cmp::Ordering;
use std::hash::{Hash, Hasher};
-use std::ops::{ControlFlow, Range};
+use std::ops::ControlFlow;
use std::{fmt, ptr, str};
pub use crate::ty::diagnostics::*;
pub mod util;
pub mod walk;
+mod adt;
mod assoc;
+mod closure;
mod consts;
mod context;
mod diagnostics;
mod list;
mod structural_impls;
mod sty;
-mod upvar;
// Data types
MutBorrow,
}
-/// Given the closure DefId this map provides a map of root variables to minimum
-/// set of `CapturedPlace`s that need to be tracked to support all captures of that closure.
-pub type MinCaptureInformationMap<'tcx> = FxHashMap<DefId, RootVariableMinCaptureList<'tcx>>;
-
-/// Part of `MinCaptureInformationMap`; Maps a root variable to the list of `CapturedPlace`.
-/// Used to track the minimum set of `Place`s that need to be captured to support all
-/// Places captured by the closure starting at a given root variable.
-///
-/// This provides a convenient and quick way of checking if a variable being used within
-/// a closure is a capture of a local variable.
-pub type RootVariableMinCaptureList<'tcx> = FxIndexMap<hir::HirId, MinCaptureList<'tcx>>;
-
-/// Part of `MinCaptureInformationMap`; List of `CapturePlace`s.
-pub type MinCaptureList<'tcx> = Vec<CapturedPlace<'tcx>>;
-
-/// A composite describing a `Place` that is captured by a closure.
-#[derive(PartialEq, Clone, Debug, TyEncodable, TyDecodable, TypeFoldable, HashStable)]
-pub struct CapturedPlace<'tcx> {
- /// The `Place` that is captured.
- pub place: HirPlace<'tcx>,
-
- /// `CaptureKind` and expression(s) that resulted in such capture of `place`.
- pub info: CaptureInfo<'tcx>,
-
- /// Represents if `place` can be mutated or not.
- pub mutability: hir::Mutability,
-}
-
-impl CapturedPlace<'tcx> {
- /// Returns the hir-id of the root variable for the captured place.
- /// e.g., if `a.b.c` was captured, would return the hir-id for `a`.
- pub fn get_root_variable(&self) -> hir::HirId {
- match self.place.base {
- HirPlaceBase::Upvar(upvar_id) => upvar_id.var_path.hir_id,
- base => bug!("Expected upvar, found={:?}", base),
- }
- }
-}
-
pub fn place_to_string_for_capture(tcx: TyCtxt<'tcx>, place: &HirPlace<'tcx>) -> String {
let name = match place.base {
HirPlaceBase::Upvar(upvar_id) => tcx.hir().name(upvar_id.var_path.hir_id).to_string(),
pub did: DefId,
}
-bitflags! {
- #[derive(HashStable)]
- pub struct AdtFlags: u32 {
- const NO_ADT_FLAGS = 0;
- /// Indicates whether the ADT is an enum.
- const IS_ENUM = 1 << 0;
- /// Indicates whether the ADT is a union.
- const IS_UNION = 1 << 1;
- /// Indicates whether the ADT is a struct.
- const IS_STRUCT = 1 << 2;
- /// Indicates whether the ADT is a struct and has a constructor.
- const HAS_CTOR = 1 << 3;
- /// Indicates whether the type is `PhantomData`.
- const IS_PHANTOM_DATA = 1 << 4;
- /// Indicates whether the type has a `#[fundamental]` attribute.
- const IS_FUNDAMENTAL = 1 << 5;
- /// Indicates whether the type is `Box`.
- const IS_BOX = 1 << 6;
- /// Indicates whether the type is `ManuallyDrop`.
- const IS_MANUALLY_DROP = 1 << 7;
- /// Indicates whether the variant list of this ADT is `#[non_exhaustive]`.
- /// (i.e., this flag is never set unless this ADT is an enum).
- const IS_VARIANT_LIST_NON_EXHAUSTIVE = 1 << 8;
- }
-}
-
bitflags! {
#[derive(HashStable)]
pub struct VariantFlags: u32 {
pub vis: Visibility,
}
-/// The definition of a user-defined type, e.g., a `struct`, `enum`, or `union`.
-///
-/// These are all interned (by `alloc_adt_def`) into the global arena.
-///
-/// The initialism *ADT* stands for an [*algebraic data type (ADT)*][adt].
-/// This is slightly wrong because `union`s are not ADTs.
-/// Moreover, Rust only allows recursive data types through indirection.
-///
-/// [adt]: https://en.wikipedia.org/wiki/Algebraic_data_type
-pub struct AdtDef {
- /// The `DefId` of the struct, enum or union item.
- pub did: DefId,
- /// Variants of the ADT. If this is a struct or union, then there will be a single variant.
- pub variants: IndexVec<VariantIdx, VariantDef>,
- /// Flags of the ADT (e.g., is this a struct? is this non-exhaustive?).
- flags: AdtFlags,
- /// Repr options provided by the user.
- pub repr: ReprOptions,
-}
-
-impl PartialOrd for AdtDef {
- fn partial_cmp(&self, other: &AdtDef) -> Option<Ordering> {
- Some(self.cmp(&other))
- }
-}
-
-/// There should be only one AdtDef for each `did`, therefore
-/// it is fine to implement `Ord` only based on `did`.
-impl Ord for AdtDef {
- fn cmp(&self, other: &AdtDef) -> Ordering {
- self.did.cmp(&other.did)
- }
-}
-
-impl PartialEq for AdtDef {
- // `AdtDef`s are always interned, and this is part of `TyS` equality.
- #[inline]
- fn eq(&self, other: &Self) -> bool {
- ptr::eq(self, other)
- }
-}
-
-impl Eq for AdtDef {}
-
-impl Hash for AdtDef {
- #[inline]
- fn hash<H: Hasher>(&self, s: &mut H) {
- (self as *const AdtDef).hash(s)
- }
-}
-
-impl<S: Encoder> Encodable<S> for AdtDef {
- fn encode(&self, s: &mut S) -> Result<(), S::Error> {
- self.did.encode(s)
- }
-}
-
-impl<'a> HashStable<StableHashingContext<'a>> for AdtDef {
- fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
- thread_local! {
- static CACHE: RefCell<FxHashMap<usize, Fingerprint>> = Default::default();
- }
-
- let hash: Fingerprint = CACHE.with(|cache| {
- let addr = self as *const AdtDef as usize;
- *cache.borrow_mut().entry(addr).or_insert_with(|| {
- let ty::AdtDef { did, ref variants, ref flags, ref repr } = *self;
-
- let mut hasher = StableHasher::new();
- did.hash_stable(hcx, &mut hasher);
- variants.hash_stable(hcx, &mut hasher);
- flags.hash_stable(hcx, &mut hasher);
- repr.hash_stable(hcx, &mut hasher);
-
- hasher.finish()
- })
- });
-
- hash.hash_stable(hcx, hasher);
- }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub enum AdtKind {
- Struct,
- Union,
- Enum,
-}
-
-impl Into<DataTypeKind> for AdtKind {
- fn into(self) -> DataTypeKind {
- match self {
- AdtKind::Struct => DataTypeKind::Struct,
- AdtKind::Union => DataTypeKind::Union,
- AdtKind::Enum => DataTypeKind::Enum,
- }
- }
-}
-
bitflags! {
#[derive(TyEncodable, TyDecodable, Default, HashStable)]
pub struct ReprFlags: u8 {
}
}
-impl<'tcx> AdtDef {
- /// Creates a new `AdtDef`.
- fn new(
- tcx: TyCtxt<'_>,
- did: DefId,
- kind: AdtKind,
- variants: IndexVec<VariantIdx, VariantDef>,
- repr: ReprOptions,
- ) -> Self {
- debug!("AdtDef::new({:?}, {:?}, {:?}, {:?})", did, kind, variants, repr);
- let mut flags = AdtFlags::NO_ADT_FLAGS;
-
- if kind == AdtKind::Enum && tcx.has_attr(did, sym::non_exhaustive) {
- debug!("found non-exhaustive variant list for {:?}", did);
- flags = flags | AdtFlags::IS_VARIANT_LIST_NON_EXHAUSTIVE;
- }
-
- flags |= match kind {
- AdtKind::Enum => AdtFlags::IS_ENUM,
- AdtKind::Union => AdtFlags::IS_UNION,
- AdtKind::Struct => AdtFlags::IS_STRUCT,
- };
-
- if kind == AdtKind::Struct && variants[VariantIdx::new(0)].ctor_def_id.is_some() {
- flags |= AdtFlags::HAS_CTOR;
- }
-
- let attrs = tcx.get_attrs(did);
- if tcx.sess.contains_name(&attrs, sym::fundamental) {
- flags |= AdtFlags::IS_FUNDAMENTAL;
- }
- if Some(did) == tcx.lang_items().phantom_data() {
- flags |= AdtFlags::IS_PHANTOM_DATA;
- }
- if Some(did) == tcx.lang_items().owned_box() {
- flags |= AdtFlags::IS_BOX;
- }
- if Some(did) == tcx.lang_items().manually_drop() {
- flags |= AdtFlags::IS_MANUALLY_DROP;
- }
-
- AdtDef { did, variants, flags, repr }
- }
-
- /// Returns `true` if this is a struct.
- #[inline]
- pub fn is_struct(&self) -> bool {
- self.flags.contains(AdtFlags::IS_STRUCT)
- }
-
- /// Returns `true` if this is a union.
- #[inline]
- pub fn is_union(&self) -> bool {
- self.flags.contains(AdtFlags::IS_UNION)
- }
-
- /// Returns `true` if this is a enum.
- #[inline]
- pub fn is_enum(&self) -> bool {
- self.flags.contains(AdtFlags::IS_ENUM)
- }
-
- /// Returns `true` if the variant list of this ADT is `#[non_exhaustive]`.
- #[inline]
- pub fn is_variant_list_non_exhaustive(&self) -> bool {
- self.flags.contains(AdtFlags::IS_VARIANT_LIST_NON_EXHAUSTIVE)
- }
-
- /// Returns the kind of the ADT.
- #[inline]
- pub fn adt_kind(&self) -> AdtKind {
- if self.is_enum() {
- AdtKind::Enum
- } else if self.is_union() {
- AdtKind::Union
- } else {
- AdtKind::Struct
- }
- }
-
- /// Returns a description of this abstract data type.
- pub fn descr(&self) -> &'static str {
- match self.adt_kind() {
- AdtKind::Struct => "struct",
- AdtKind::Union => "union",
- AdtKind::Enum => "enum",
- }
- }
-
- /// Returns a description of a variant of this abstract data type.
- #[inline]
- pub fn variant_descr(&self) -> &'static str {
- match self.adt_kind() {
- AdtKind::Struct => "struct",
- AdtKind::Union => "union",
- AdtKind::Enum => "variant",
- }
- }
-
- /// If this function returns `true`, it implies that `is_struct` must return `true`.
- #[inline]
- pub fn has_ctor(&self) -> bool {
- self.flags.contains(AdtFlags::HAS_CTOR)
- }
-
- /// Returns `true` if this type is `#[fundamental]` for the purposes
- /// of coherence checking.
- #[inline]
- pub fn is_fundamental(&self) -> bool {
- self.flags.contains(AdtFlags::IS_FUNDAMENTAL)
- }
-
- /// Returns `true` if this is `PhantomData<T>`.
- #[inline]
- pub fn is_phantom_data(&self) -> bool {
- self.flags.contains(AdtFlags::IS_PHANTOM_DATA)
- }
-
- /// Returns `true` if this is Box<T>.
- #[inline]
- pub fn is_box(&self) -> bool {
- self.flags.contains(AdtFlags::IS_BOX)
- }
-
- /// Returns `true` if this is `ManuallyDrop<T>`.
- #[inline]
- pub fn is_manually_drop(&self) -> bool {
- self.flags.contains(AdtFlags::IS_MANUALLY_DROP)
- }
-
- /// Returns `true` if this type has a destructor.
- pub fn has_dtor(&self, tcx: TyCtxt<'tcx>) -> bool {
- self.destructor(tcx).is_some()
- }
-
- /// Asserts this is a struct or union and returns its unique variant.
- pub fn non_enum_variant(&self) -> &VariantDef {
- assert!(self.is_struct() || self.is_union());
- &self.variants[VariantIdx::new(0)]
- }
-
- #[inline]
- pub fn predicates(&self, tcx: TyCtxt<'tcx>) -> GenericPredicates<'tcx> {
- tcx.predicates_of(self.did)
- }
-
- /// Returns an iterator over all fields contained
- /// by this ADT.
- #[inline]
- pub fn all_fields(&self) -> impl Iterator<Item = &FieldDef> + Clone {
- self.variants.iter().flat_map(|v| v.fields.iter())
- }
-
- /// Whether the ADT lacks fields. Note that this includes uninhabited enums,
- /// e.g., `enum Void {}` is considered payload free as well.
- pub fn is_payloadfree(&self) -> bool {
- self.variants.iter().all(|v| v.fields.is_empty())
- }
-
- /// Return a `VariantDef` given a variant id.
- pub fn variant_with_id(&self, vid: DefId) -> &VariantDef {
- self.variants.iter().find(|v| v.def_id == vid).expect("variant_with_id: unknown variant")
- }
-
- /// Return a `VariantDef` given a constructor id.
- pub fn variant_with_ctor_id(&self, cid: DefId) -> &VariantDef {
- self.variants
- .iter()
- .find(|v| v.ctor_def_id == Some(cid))
- .expect("variant_with_ctor_id: unknown variant")
- }
-
- /// Return the index of `VariantDef` given a variant id.
- pub fn variant_index_with_id(&self, vid: DefId) -> VariantIdx {
- self.variants
- .iter_enumerated()
- .find(|(_, v)| v.def_id == vid)
- .expect("variant_index_with_id: unknown variant")
- .0
- }
-
- /// Return the index of `VariantDef` given a constructor id.
- pub fn variant_index_with_ctor_id(&self, cid: DefId) -> VariantIdx {
- self.variants
- .iter_enumerated()
- .find(|(_, v)| v.ctor_def_id == Some(cid))
- .expect("variant_index_with_ctor_id: unknown variant")
- .0
- }
-
- pub fn variant_of_res(&self, res: Res) -> &VariantDef {
- match res {
- Res::Def(DefKind::Variant, vid) => self.variant_with_id(vid),
- Res::Def(DefKind::Ctor(..), cid) => self.variant_with_ctor_id(cid),
- Res::Def(DefKind::Struct, _)
- | Res::Def(DefKind::Union, _)
- | Res::Def(DefKind::TyAlias, _)
- | Res::Def(DefKind::AssocTy, _)
- | Res::SelfTy(..)
- | Res::SelfCtor(..) => self.non_enum_variant(),
- _ => bug!("unexpected res {:?} in variant_of_res", res),
- }
- }
-
- #[inline]
- pub fn eval_explicit_discr(&self, tcx: TyCtxt<'tcx>, expr_did: DefId) -> Option<Discr<'tcx>> {
- assert!(self.is_enum());
- let param_env = tcx.param_env(expr_did);
- let repr_type = self.repr.discr_type();
- match tcx.const_eval_poly(expr_did) {
- Ok(val) => {
- let ty = repr_type.to_ty(tcx);
- if let Some(b) = val.try_to_bits_for_ty(tcx, param_env, ty) {
- trace!("discriminants: {} ({:?})", b, repr_type);
- Some(Discr { val: b, ty })
- } else {
- info!("invalid enum discriminant: {:#?}", val);
- crate::mir::interpret::struct_error(
- tcx.at(tcx.def_span(expr_did)),
- "constant evaluation of enum discriminant resulted in non-integer",
- )
- .emit();
- None
- }
- }
- Err(err) => {
- let msg = match err {
- ErrorHandled::Reported(ErrorReported) | ErrorHandled::Linted => {
- "enum discriminant evaluation failed"
- }
- ErrorHandled::TooGeneric => "enum discriminant depends on generics",
- };
- tcx.sess.delay_span_bug(tcx.def_span(expr_did), msg);
- None
- }
- }
- }
-
- #[inline]
- pub fn discriminants(
- &'tcx self,
- tcx: TyCtxt<'tcx>,
- ) -> impl Iterator<Item = (VariantIdx, Discr<'tcx>)> + Captures<'tcx> {
- assert!(self.is_enum());
- let repr_type = self.repr.discr_type();
- let initial = repr_type.initial_discriminant(tcx);
- let mut prev_discr = None::<Discr<'tcx>>;
- self.variants.iter_enumerated().map(move |(i, v)| {
- let mut discr = prev_discr.map_or(initial, |d| d.wrap_incr(tcx));
- if let VariantDiscr::Explicit(expr_did) = v.discr {
- if let Some(new_discr) = self.eval_explicit_discr(tcx, expr_did) {
- discr = new_discr;
- }
- }
- prev_discr = Some(discr);
-
- (i, discr)
- })
- }
-
- #[inline]
- pub fn variant_range(&self) -> Range<VariantIdx> {
- VariantIdx::new(0)..VariantIdx::new(self.variants.len())
- }
-
- /// Computes the discriminant value used by a specific variant.
- /// Unlike `discriminants`, this is (amortized) constant-time,
- /// only doing at most one query for evaluating an explicit
- /// discriminant (the last one before the requested variant),
- /// assuming there are no constant-evaluation errors there.
- #[inline]
- pub fn discriminant_for_variant(
- &self,
- tcx: TyCtxt<'tcx>,
- variant_index: VariantIdx,
- ) -> Discr<'tcx> {
- assert!(self.is_enum());
- let (val, offset) = self.discriminant_def_for_variant(variant_index);
- let explicit_value = val
- .and_then(|expr_did| self.eval_explicit_discr(tcx, expr_did))
- .unwrap_or_else(|| self.repr.discr_type().initial_discriminant(tcx));
- explicit_value.checked_add(tcx, offset as u128).0
- }
-
- /// Yields a `DefId` for the discriminant and an offset to add to it
- /// Alternatively, if there is no explicit discriminant, returns the
- /// inferred discriminant directly.
- pub fn discriminant_def_for_variant(&self, variant_index: VariantIdx) -> (Option<DefId>, u32) {
- assert!(!self.variants.is_empty());
- let mut explicit_index = variant_index.as_u32();
- let expr_did;
- loop {
- match self.variants[VariantIdx::from_u32(explicit_index)].discr {
- ty::VariantDiscr::Relative(0) => {
- expr_did = None;
- break;
- }
- ty::VariantDiscr::Relative(distance) => {
- explicit_index -= distance;
- }
- ty::VariantDiscr::Explicit(did) => {
- expr_did = Some(did);
- break;
- }
- }
- }
- (expr_did, variant_index.as_u32() - explicit_index)
- }
-
- pub fn destructor(&self, tcx: TyCtxt<'tcx>) -> Option<Destructor> {
- tcx.adt_destructor(self.did)
- }
-
- /// Returns a list of types such that `Self: Sized` if and only
- /// if that type is `Sized`, or `TyErr` if this type is recursive.
- ///
- /// Oddly enough, checking that the sized-constraint is `Sized` is
- /// actually more expressive than checking all members:
- /// the `Sized` trait is inductive, so an associated type that references
- /// `Self` would prevent its containing ADT from being `Sized`.
- ///
- /// Due to normalization being eager, this applies even if
- /// the associated type is behind a pointer (e.g., issue #31299).
- pub fn sized_constraint(&self, tcx: TyCtxt<'tcx>) -> &'tcx [Ty<'tcx>] {
- tcx.adt_sized_constraint(self.did).0
- }
-}
-
impl<'tcx> FieldDef {
/// Returns the type of this field. The `subst` is typically obtained
/// via the second field of `TyKind::AdtDef`.
}
}
-/// Represents the various closure traits in the language. This
-/// will determine the type of the environment (`self`, in the
-/// desugaring) argument that the closure expects.
-///
-/// You can get the environment type of a closure using
-/// `tcx.closure_env_ty()`.
-#[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash, Debug, TyEncodable, TyDecodable)]
-#[derive(HashStable)]
-pub enum ClosureKind {
- // Warning: Ordering is significant here! The ordering is chosen
- // because the trait Fn is a subtrait of FnMut and so in turn, and
- // hence we order it so that Fn < FnMut < FnOnce.
- Fn,
- FnMut,
- FnOnce,
-}
-
-impl<'tcx> ClosureKind {
- // This is the initial value used when doing upvar inference.
- pub const LATTICE_BOTTOM: ClosureKind = ClosureKind::Fn;
-
- pub fn trait_did(&self, tcx: TyCtxt<'tcx>) -> DefId {
- match *self {
- ClosureKind::Fn => tcx.require_lang_item(LangItem::Fn, None),
- ClosureKind::FnMut => tcx.require_lang_item(LangItem::FnMut, None),
- ClosureKind::FnOnce => tcx.require_lang_item(LangItem::FnOnce, None),
- }
- }
-
- /// Returns `true` if a type that impls this closure kind
- /// must also implement `other`.
- pub fn extends(self, other: ty::ClosureKind) -> bool {
- matches!(
- (self, other),
- (ClosureKind::Fn, ClosureKind::Fn)
- | (ClosureKind::Fn, ClosureKind::FnMut)
- | (ClosureKind::Fn, ClosureKind::FnOnce)
- | (ClosureKind::FnMut, ClosureKind::FnMut)
- | (ClosureKind::FnMut, ClosureKind::FnOnce)
- | (ClosureKind::FnOnce, ClosureKind::FnOnce)
- )
- }
-
- /// Returns the representative scalar type for this closure kind.
- /// See `TyS::to_opt_closure_kind` for more details.
- pub fn to_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
- match self {
- ty::ClosureKind::Fn => tcx.types.i8,
- ty::ClosureKind::FnMut => tcx.types.i16,
- ty::ClosureKind::FnOnce => tcx.types.i32,
- }
- }
-}
-
impl BorrowKind {
pub fn from_mutbl(m: hir::Mutability) -> BorrowKind {
match m {
}
}
-#[derive(Clone, HashStable, Debug)]
-pub struct AdtSizedConstraint<'tcx>(pub &'tcx [Ty<'tcx>]);
-
/// Yields the parent function's `DefId` if `def_id` is an `impl Trait` definition.
pub fn is_impl_trait_defn(tcx: TyCtxt<'_>, def_id: DefId) -> Option<DefId> {
if let Some(def_id) = def_id.as_local() {
projects / rust.git / blobdiff