// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![allow(non_camel_case_types)] pub use self::terr_vstore_kind::*; pub use self::type_err::*; pub use self::BuiltinBound::*; pub use self::InferTy::*; pub use self::InferRegion::*; pub use self::ImplOrTraitItemId::*; pub use self::UnboxedClosureKind::*; pub use self::TraitStore::*; pub use self::ast_ty_to_ty_cache_entry::*; pub use self::Variance::*; pub use self::AutoAdjustment::*; pub use self::Representability::*; pub use self::UnsizeKind::*; pub use self::AutoRef::*; pub use self::ExprKind::*; pub use self::DtorKind::*; pub use self::ExplicitSelfCategory::*; pub use self::FnOutput::*; pub use self::Region::*; pub use self::ImplOrTraitItemContainer::*; pub use self::BorrowKind::*; pub use self::ImplOrTraitItem::*; pub use self::BoundRegion::*; pub use self::sty::*; pub use self::IntVarValue::*; pub use self::ExprAdjustment::*; pub use self::vtable_origin::*; pub use self::MethodOrigin::*; pub use self::CopyImplementationError::*; use back::svh::Svh; use session::Session; use lint; use metadata::csearch; use middle; use middle::const_eval; use middle::def::{self, DefMap, ExportMap}; use middle::dependency_format; use middle::lang_items::{FnTraitLangItem, FnMutTraitLangItem}; use middle::lang_items::{FnOnceTraitLangItem, TyDescStructLangItem}; use middle::mem_categorization as mc; use middle::region; use middle::resolve_lifetime; use middle::infer; use middle::stability; use middle::subst::{self, Subst, Substs, VecPerParamSpace}; use middle::traits; use middle::ty; use middle::ty_fold::{self, TypeFoldable, TypeFolder}; use middle::ty_walk::TypeWalker; use util::ppaux::{note_and_explain_region, bound_region_ptr_to_string}; use util::ppaux::{trait_store_to_string, ty_to_string}; use util::ppaux::{Repr, UserString}; use util::common::{memoized, ErrorReported}; use util::nodemap::{NodeMap, NodeSet, DefIdMap, DefIdSet}; use util::nodemap::{FnvHashMap}; use arena::TypedArena; use std::borrow::BorrowFrom; use std::cell::{Cell, RefCell}; use std::cmp::{self, Ordering}; use std::fmt::{self, Show}; use std::hash::{Hash, sip, Writer}; use std::mem; use std::ops; use std::rc::Rc; use collections::enum_set::{EnumSet, CLike}; use std::collections::{HashMap, HashSet}; use syntax::abi; use syntax::ast::{CrateNum, DefId, Ident, ItemTrait, LOCAL_CRATE}; use syntax::ast::{MutImmutable, MutMutable, Name, NamedField, NodeId}; use syntax::ast::{Onceness, StmtExpr, StmtSemi, StructField, UnnamedField}; use syntax::ast::{Visibility}; use syntax::ast_util::{self, is_local, lit_is_str, local_def, PostExpansionMethod}; use syntax::attr::{self, AttrMetaMethods}; use syntax::codemap::Span; use syntax::parse::token::{self, InternedString, special_idents}; use syntax::{ast, ast_map}; pub type Disr = u64; pub const INITIAL_DISCRIMINANT_VALUE: Disr = 0; // Data types /// The complete set of all analyses described in this module. This is /// produced by the driver and fed to trans and later passes. pub struct CrateAnalysis<'tcx> { pub export_map: ExportMap, pub exported_items: middle::privacy::ExportedItems, pub public_items: middle::privacy::PublicItems, pub ty_cx: ty::ctxt<'tcx>, pub reachable: NodeSet, pub name: String, pub glob_map: Option, } #[derive(Copy, PartialEq, Eq, Hash)] pub struct field<'tcx> { pub name: ast::Name, pub mt: mt<'tcx> } #[derive(Clone, Copy, Show)] pub enum ImplOrTraitItemContainer { TraitContainer(ast::DefId), ImplContainer(ast::DefId), } impl ImplOrTraitItemContainer { pub fn id(&self) -> ast::DefId { match *self { TraitContainer(id) => id, ImplContainer(id) => id, } } } #[derive(Clone, Show)] pub enum ImplOrTraitItem<'tcx> { MethodTraitItem(Rc>), TypeTraitItem(Rc), } impl<'tcx> ImplOrTraitItem<'tcx> { fn id(&self) -> ImplOrTraitItemId { match *self { MethodTraitItem(ref method) => MethodTraitItemId(method.def_id), TypeTraitItem(ref associated_type) => { TypeTraitItemId(associated_type.def_id) } } } pub fn def_id(&self) -> ast::DefId { match *self { MethodTraitItem(ref method) => method.def_id, TypeTraitItem(ref associated_type) => associated_type.def_id, } } pub fn name(&self) -> ast::Name { match *self { MethodTraitItem(ref method) => method.name, TypeTraitItem(ref associated_type) => associated_type.name, } } pub fn container(&self) -> ImplOrTraitItemContainer { match *self { MethodTraitItem(ref method) => method.container, TypeTraitItem(ref associated_type) => associated_type.container, } } pub fn as_opt_method(&self) -> Option>> { match *self { MethodTraitItem(ref m) => Some((*m).clone()), TypeTraitItem(_) => None } } } #[derive(Clone, Copy, Show)] pub enum ImplOrTraitItemId { MethodTraitItemId(ast::DefId), TypeTraitItemId(ast::DefId), } impl ImplOrTraitItemId { pub fn def_id(&self) -> ast::DefId { match *self { MethodTraitItemId(def_id) => def_id, TypeTraitItemId(def_id) => def_id, } } } #[derive(Clone, Show)] pub struct Method<'tcx> { pub name: ast::Name, pub generics: ty::Generics<'tcx>, pub fty: BareFnTy<'tcx>, pub explicit_self: ExplicitSelfCategory, pub vis: ast::Visibility, pub def_id: ast::DefId, pub container: ImplOrTraitItemContainer, // If this method is provided, we need to know where it came from pub provided_source: Option } impl<'tcx> Method<'tcx> { pub fn new(name: ast::Name, generics: ty::Generics<'tcx>, fty: BareFnTy<'tcx>, explicit_self: ExplicitSelfCategory, vis: ast::Visibility, def_id: ast::DefId, container: ImplOrTraitItemContainer, provided_source: Option) -> Method<'tcx> { Method { name: name, generics: generics, fty: fty, explicit_self: explicit_self, vis: vis, def_id: def_id, container: container, provided_source: provided_source } } pub fn container_id(&self) -> ast::DefId { match self.container { TraitContainer(id) => id, ImplContainer(id) => id, } } } #[derive(Clone, Copy, Show)] pub struct AssociatedType { pub name: ast::Name, pub vis: ast::Visibility, pub def_id: ast::DefId, pub container: ImplOrTraitItemContainer, } #[derive(Clone, Copy, PartialEq, Eq, Hash, Show)] pub struct mt<'tcx> { pub ty: Ty<'tcx>, pub mutbl: ast::Mutability, } #[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Show)] pub enum TraitStore { /// Box UniqTraitStore, /// &Trait and &mut Trait RegionTraitStore(Region, ast::Mutability), } #[derive(Clone, Copy, Show)] pub struct field_ty { pub name: Name, pub id: DefId, pub vis: ast::Visibility, pub origin: ast::DefId, // The DefId of the struct in which the field is declared. } // Contains information needed to resolve types and (in the future) look up // the types of AST nodes. #[derive(Copy, PartialEq, Eq, Hash)] pub struct creader_cache_key { pub cnum: CrateNum, pub pos: uint, pub len: uint } #[derive(Copy)] pub enum ast_ty_to_ty_cache_entry<'tcx> { atttce_unresolved, /* not resolved yet */ atttce_resolved(Ty<'tcx>) /* resolved to a type, irrespective of region */ } #[derive(Clone, PartialEq, RustcDecodable, RustcEncodable)] pub struct ItemVariances { pub types: VecPerParamSpace, pub regions: VecPerParamSpace, } #[derive(Clone, PartialEq, RustcDecodable, RustcEncodable, Show, Copy)] pub enum Variance { Covariant, // T <: T iff A <: B -- e.g., function return type Invariant, // T <: T iff B == A -- e.g., type of mutable cell Contravariant, // T <: T iff B <: A -- e.g., function param type Bivariant, // T <: T -- e.g., unused type parameter } #[derive(Clone, Show)] pub enum AutoAdjustment<'tcx> { AdjustReifyFnPointer(ast::DefId), // go from a fn-item type to a fn-pointer type AdjustDerefRef(AutoDerefRef<'tcx>) } #[derive(Clone, PartialEq, Show)] pub enum UnsizeKind<'tcx> { // [T, ..n] -> [T], the uint field is n. UnsizeLength(uint), // An unsize coercion applied to the tail field of a struct. // The uint is the index of the type parameter which is unsized. UnsizeStruct(Box>, uint), UnsizeVtable(TyTrait<'tcx>, /* the self type of the trait */ Ty<'tcx>) } #[derive(Clone, Show)] pub struct AutoDerefRef<'tcx> { pub autoderefs: uint, pub autoref: Option> } #[derive(Clone, PartialEq, Show)] pub enum AutoRef<'tcx> { /// Convert from T to &T /// The third field allows us to wrap other AutoRef adjustments. AutoPtr(Region, ast::Mutability, Option>>), /// Convert [T, ..n] to [T] (or similar, depending on the kind) AutoUnsize(UnsizeKind<'tcx>), /// Convert Box<[T, ..n]> to Box<[T]> or something similar in a Box. /// With DST and Box a library type, this should be replaced by UnsizeStruct. AutoUnsizeUniq(UnsizeKind<'tcx>), /// Convert from T to *T /// Value to thin pointer /// The second field allows us to wrap other AutoRef adjustments. AutoUnsafe(ast::Mutability, Option>>), } // Ugly little helper function. The first bool in the returned tuple is true if // there is an 'unsize to trait object' adjustment at the bottom of the // adjustment. If that is surrounded by an AutoPtr, then we also return the // region of the AutoPtr (in the third argument). The second bool is true if the // adjustment is unique. fn autoref_object_region(autoref: &AutoRef) -> (bool, bool, Option) { fn unsize_kind_is_object(k: &UnsizeKind) -> bool { match k { &UnsizeVtable(..) => true, &UnsizeStruct(box ref k, _) => unsize_kind_is_object(k), _ => false } } match autoref { &AutoUnsize(ref k) => (unsize_kind_is_object(k), false, None), &AutoUnsizeUniq(ref k) => (unsize_kind_is_object(k), true, None), &AutoPtr(adj_r, _, Some(box ref autoref)) => { let (b, u, r) = autoref_object_region(autoref); if r.is_some() || u { (b, u, r) } else { (b, u, Some(adj_r)) } } &AutoUnsafe(_, Some(box ref autoref)) => autoref_object_region(autoref), _ => (false, false, None) } } // If the adjustment introduces a borrowed reference to a trait object, then // returns the region of the borrowed reference. pub fn adjusted_object_region(adj: &AutoAdjustment) -> Option { match adj { &AdjustDerefRef(AutoDerefRef{autoref: Some(ref autoref), ..}) => { let (b, _, r) = autoref_object_region(autoref); if b { r } else { None } } _ => None } } // Returns true if there is a trait cast at the bottom of the adjustment. pub fn adjust_is_object(adj: &AutoAdjustment) -> bool { match adj { &AdjustDerefRef(AutoDerefRef{autoref: Some(ref autoref), ..}) => { let (b, _, _) = autoref_object_region(autoref); b } _ => false } } // If possible, returns the type expected from the given adjustment. This is not // possible if the adjustment depends on the type of the adjusted expression. pub fn type_of_adjust<'tcx>(cx: &ctxt<'tcx>, adj: &AutoAdjustment<'tcx>) -> Option> { fn type_of_autoref<'tcx>(cx: &ctxt<'tcx>, autoref: &AutoRef<'tcx>) -> Option> { match autoref { &AutoUnsize(ref k) => match k { &UnsizeVtable(TyTrait { ref principal, ref bounds }, _) => { Some(mk_trait(cx, principal.clone(), bounds.clone())) } _ => None }, &AutoUnsizeUniq(ref k) => match k { &UnsizeVtable(TyTrait { ref principal, ref bounds }, _) => { Some(mk_uniq(cx, mk_trait(cx, principal.clone(), bounds.clone()))) } _ => None }, &AutoPtr(r, m, Some(box ref autoref)) => { match type_of_autoref(cx, autoref) { Some(ty) => Some(mk_rptr(cx, cx.mk_region(r), mt {mutbl: m, ty: ty})), None => None } } &AutoUnsafe(m, Some(box ref autoref)) => { match type_of_autoref(cx, autoref) { Some(ty) => Some(mk_ptr(cx, mt {mutbl: m, ty: ty})), None => None } } _ => None } } match adj { &AdjustDerefRef(AutoDerefRef{autoref: Some(ref autoref), ..}) => { type_of_autoref(cx, autoref) } _ => None } } #[derive(Clone, Copy, RustcEncodable, RustcDecodable, PartialEq, PartialOrd, Show)] pub struct param_index { pub space: subst::ParamSpace, pub index: uint } #[derive(Clone, Show)] pub enum MethodOrigin<'tcx> { // fully statically resolved method MethodStatic(ast::DefId), // fully statically resolved unboxed closure invocation MethodStaticUnboxedClosure(ast::DefId), // method invoked on a type parameter with a bounded trait MethodTypeParam(MethodParam<'tcx>), // method invoked on a trait instance MethodTraitObject(MethodObject<'tcx>), } // details for a method invoked with a receiver whose type is a type parameter // with a bounded trait. #[derive(Clone, Show)] pub struct MethodParam<'tcx> { // the precise trait reference that occurs as a bound -- this may // be a supertrait of what the user actually typed. Note that it // never contains bound regions; those regions should have been // instantiated with fresh variables at this point. pub trait_ref: Rc>, // index of uint in the list of methods for the trait pub method_num: uint, } // details for a method invoked with a receiver whose type is an object #[derive(Clone, Show)] pub struct MethodObject<'tcx> { // the (super)trait containing the method to be invoked pub trait_ref: Rc>, // the actual base trait id of the object pub object_trait_id: ast::DefId, // index of the method to be invoked amongst the trait's methods pub method_num: uint, // index into the actual runtime vtable. // the vtable is formed by concatenating together the method lists of // the base object trait and all supertraits; this is the index into // that vtable pub real_index: uint, } #[derive(Clone)] pub struct MethodCallee<'tcx> { pub origin: MethodOrigin<'tcx>, pub ty: Ty<'tcx>, pub substs: subst::Substs<'tcx> } /// With method calls, we store some extra information in /// side tables (i.e method_map). We use /// MethodCall as a key to index into these tables instead of /// just directly using the expression's NodeId. The reason /// for this being that we may apply adjustments (coercions) /// with the resulting expression also needing to use the /// side tables. The problem with this is that we don't /// assign a separate NodeId to this new expression /// and so it would clash with the base expression if both /// needed to add to the side tables. Thus to disambiguate /// we also keep track of whether there's an adjustment in /// our key. #[derive(Clone, Copy, PartialEq, Eq, Hash, Show)] pub struct MethodCall { pub expr_id: ast::NodeId, pub adjustment: ExprAdjustment } #[derive(Clone, PartialEq, Eq, Hash, Show, RustcEncodable, RustcDecodable, Copy)] pub enum ExprAdjustment { NoAdjustment, AutoDeref(uint), AutoObject } impl MethodCall { pub fn expr(id: ast::NodeId) -> MethodCall { MethodCall { expr_id: id, adjustment: NoAdjustment } } pub fn autoobject(id: ast::NodeId) -> MethodCall { MethodCall { expr_id: id, adjustment: AutoObject } } pub fn autoderef(expr_id: ast::NodeId, autoderef: uint) -> MethodCall { MethodCall { expr_id: expr_id, adjustment: AutoDeref(1 + autoderef) } } } // maps from an expression id that corresponds to a method call to the details // of the method to be invoked pub type MethodMap<'tcx> = RefCell>>; pub type vtable_param_res<'tcx> = Vec>; // Resolutions for bounds of all parameters, left to right, for a given path. pub type vtable_res<'tcx> = VecPerParamSpace>; #[derive(Clone)] pub enum vtable_origin<'tcx> { /* Statically known vtable. def_id gives the impl item from whence comes the vtable, and tys are the type substs. vtable_res is the vtable itself. */ vtable_static(ast::DefId, subst::Substs<'tcx>, vtable_res<'tcx>), /* Dynamic vtable, comes from a parameter that has a bound on it: fn foo(a: T) -- a's vtable would have a vtable_param origin The first argument is the param index (identifying T in the example), and the second is the bound number (identifying baz) */ vtable_param(param_index, uint), /* Vtable automatically generated for an unboxed closure. The def ID is the ID of the closure expression. */ vtable_unboxed_closure(ast::DefId), /* Asked to determine the vtable for ty_err. This is the value used for the vtables of `Self` in a virtual call like `foo.bar()` where `foo` is of object type. The same value is also used when type errors occur. */ vtable_error, } // For every explicit cast into an object type, maps from the cast // expr to the associated trait ref. pub type ObjectCastMap<'tcx> = RefCell>>; /// A restriction that certain types must be the same size. The use of /// `transmute` gives rise to these restrictions. These generally /// cannot be checked until trans; therefore, each call to `transmute` /// will push one or more such restriction into the /// `transmute_restrictions` vector during `intrinsicck`. They are /// then checked during `trans` by the fn `check_intrinsics`. #[derive(Copy)] pub struct TransmuteRestriction<'tcx> { /// The span whence the restriction comes. pub span: Span, /// The type being transmuted from. pub original_from: Ty<'tcx>, /// The type being transmuted to. pub original_to: Ty<'tcx>, /// The type being transmuted from, with all type parameters /// substituted for an arbitrary representative. Not to be shown /// to the end user. pub substituted_from: Ty<'tcx>, /// The type being transmuted to, with all type parameters /// substituted for an arbitrary representative. Not to be shown /// to the end user. pub substituted_to: Ty<'tcx>, /// NodeId of the transmute intrinsic. pub id: ast::NodeId, } /// Internal storage pub struct CtxtArenas<'tcx> { type_: TypedArena>, substs: TypedArena>, bare_fn: TypedArena>, region: TypedArena, } impl<'tcx> CtxtArenas<'tcx> { pub fn new() -> CtxtArenas<'tcx> { CtxtArenas { type_: TypedArena::new(), substs: TypedArena::new(), bare_fn: TypedArena::new(), region: TypedArena::new(), } } } pub struct CommonTypes<'tcx> { pub bool: Ty<'tcx>, pub char: Ty<'tcx>, pub int: Ty<'tcx>, pub i8: Ty<'tcx>, pub i16: Ty<'tcx>, pub i32: Ty<'tcx>, pub i64: Ty<'tcx>, pub uint: Ty<'tcx>, pub u8: Ty<'tcx>, pub u16: Ty<'tcx>, pub u32: Ty<'tcx>, pub u64: Ty<'tcx>, pub f32: Ty<'tcx>, pub f64: Ty<'tcx>, pub err: Ty<'tcx>, } /// The data structure to keep track of all the information that typechecker /// generates so that so that it can be reused and doesn't have to be redone /// later on. pub struct ctxt<'tcx> { /// The arenas that types etc are allocated from. arenas: &'tcx CtxtArenas<'tcx>, /// Specifically use a speedy hash algorithm for this hash map, it's used /// quite often. // FIXME(eddyb) use a FnvHashSet> when equivalent keys can // queried from a HashSet. interner: RefCell, Ty<'tcx>>>, // FIXME as above, use a hashset if equivalent elements can be queried. substs_interner: RefCell, &'tcx Substs<'tcx>>>, bare_fn_interner: RefCell, &'tcx BareFnTy<'tcx>>>, region_interner: RefCell>, /// Common types, pre-interned for your convenience. pub types: CommonTypes<'tcx>, pub sess: Session, pub def_map: DefMap, pub named_region_map: resolve_lifetime::NamedRegionMap, pub region_maps: middle::region::RegionMaps, /// Stores the types for various nodes in the AST. Note that this table /// is not guaranteed to be populated until after typeck. See /// typeck::check::fn_ctxt for details. pub node_types: RefCell>>, /// Stores the type parameters which were substituted to obtain the type /// of this node. This only applies to nodes that refer to entities /// parameterized by type parameters, such as generic fns, types, or /// other items. pub item_substs: RefCell>>, /// Maps from a trait item to the trait item "descriptor" pub impl_or_trait_items: RefCell>>, /// Maps from a trait def-id to a list of the def-ids of its trait items pub trait_item_def_ids: RefCell>>>, /// A cache for the trait_items() routine pub trait_items_cache: RefCell>>>>, pub impl_trait_cache: RefCell>>>>, pub trait_refs: RefCell>>>, pub trait_defs: RefCell>>>, /// Maps from node-id of a trait object cast (like `foo as /// Box`) to the trait reference. pub object_cast_map: ObjectCastMap<'tcx>, pub map: ast_map::Map<'tcx>, pub intrinsic_defs: RefCell>>, pub freevars: RefCell, pub tcache: RefCell>>, pub rcache: RefCell>>, pub short_names_cache: RefCell, String>>, pub tc_cache: RefCell, TypeContents>>, pub ast_ty_to_ty_cache: RefCell>>, pub enum_var_cache: RefCell>>>>>, pub ty_param_defs: RefCell>>, pub adjustments: RefCell>>, pub normalized_cache: RefCell, Ty<'tcx>>>, pub lang_items: middle::lang_items::LanguageItems, /// A mapping of fake provided method def_ids to the default implementation pub provided_method_sources: RefCell>, pub struct_fields: RefCell>>>, /// Maps from def-id of a type or region parameter to its /// (inferred) variance. pub item_variance_map: RefCell>>, /// True if the variance has been computed yet; false otherwise. pub variance_computed: Cell, /// A mapping from the def ID of an enum or struct type to the def ID /// of the method that implements its destructor. If the type is not /// present in this map, it does not have a destructor. This map is /// populated during the coherence phase of typechecking. pub destructor_for_type: RefCell>, /// A method will be in this list if and only if it is a destructor. pub destructors: RefCell, /// Maps a trait onto a list of impls of that trait. pub trait_impls: RefCell>>>>, /// Maps a DefId of a type to a list of its inherent impls. /// Contains implementations of methods that are inherent to a type. /// Methods in these implementations don't need to be exported. pub inherent_impls: RefCell>>>, /// Maps a DefId of an impl to a list of its items. /// Note that this contains all of the impls that we know about, /// including ones in other crates. It's not clear that this is the best /// way to do it. pub impl_items: RefCell>>, /// Set of used unsafe nodes (functions or blocks). Unsafe nodes not /// present in this set can be warned about. pub used_unsafe: RefCell, /// Set of nodes which mark locals as mutable which end up getting used at /// some point. Local variable definitions not in this set can be warned /// about. pub used_mut_nodes: RefCell, /// The set of external nominal types whose implementations have been read. /// This is used for lazy resolution of methods. pub populated_external_types: RefCell, /// The set of external traits whose implementations have been read. This /// is used for lazy resolution of traits. pub populated_external_traits: RefCell, /// Borrows pub upvar_borrow_map: RefCell, /// These two caches are used by const_eval when decoding external statics /// and variants that are found. pub extern_const_statics: RefCell>, pub extern_const_variants: RefCell>, pub method_map: MethodMap<'tcx>, pub dependency_formats: RefCell, /// Records the type of each unboxed closure. The def ID is the ID of the /// expression defining the unboxed closure. pub unboxed_closures: RefCell>>, pub node_lint_levels: RefCell>, /// The types that must be asserted to be the same size for `transmute` /// to be valid. We gather up these restrictions in the intrinsicck pass /// and check them in trans. pub transmute_restrictions: RefCell>>, /// Maps any item's def-id to its stability index. pub stability: RefCell, /// Maps closures to their capture clauses. pub capture_modes: RefCell, /// Maps def IDs to true if and only if they're associated types. pub associated_types: RefCell>, /// Caches the results of trait selection. This cache is used /// for things that do not have to do with the parameters in scope. pub selection_cache: traits::SelectionCache<'tcx>, /// Caches the representation hints for struct definitions. pub repr_hint_cache: RefCell>>>, /// Caches whether types are known to impl Copy. Note that type /// parameters are never placed into this cache, because their /// results are dependent on the parameter environment. pub type_impls_copy_cache: RefCell,bool>>, /// Caches whether types are known to impl Sized. Note that type /// parameters are never placed into this cache, because their /// results are dependent on the parameter environment. pub type_impls_sized_cache: RefCell,bool>>, /// Caches whether traits are object safe pub object_safety_cache: RefCell>, } // Flags that we track on types. These flags are propagated upwards // through the type during type construction, so that we can quickly // check whether the type has various kinds of types in it without // recursing over the type itself. bitflags! { flags TypeFlags: u32 { const NO_TYPE_FLAGS = 0b0, const HAS_PARAMS = 0b1, const HAS_SELF = 0b10, const HAS_TY_INFER = 0b100, const HAS_RE_INFER = 0b1000, const HAS_RE_LATE_BOUND = 0b10000, const HAS_REGIONS = 0b100000, const HAS_TY_ERR = 0b1000000, const HAS_PROJECTION = 0b10000000, const NEEDS_SUBST = HAS_PARAMS.bits | HAS_SELF.bits | HAS_REGIONS.bits, } } macro_rules! sty_debug_print { ($ctxt: expr, $($variant: ident),*) => {{ // curious inner module to allow variant names to be used as // variable names. mod inner { use middle::ty; #[derive(Copy)] struct DebugStat { total: uint, region_infer: uint, ty_infer: uint, both_infer: uint, } pub fn go(tcx: &ty::ctxt) { let mut total = DebugStat { total: 0, region_infer: 0, ty_infer: 0, both_infer: 0, }; $(let mut $variant = total;)* for (_, t) in tcx.interner.borrow().iter() { let variant = match t.sty { ty::ty_bool | ty::ty_char | ty::ty_int(..) | ty::ty_uint(..) | ty::ty_float(..) | ty::ty_str => continue, ty::ty_err => /* unimportant */ continue, $(ty::$variant(..) => &mut $variant,)* }; let region = t.flags.intersects(ty::HAS_RE_INFER); let ty = t.flags.intersects(ty::HAS_TY_INFER); variant.total += 1; total.total += 1; if region { total.region_infer += 1; variant.region_infer += 1 } if ty { total.ty_infer += 1; variant.ty_infer += 1 } if region && ty { total.both_infer += 1; variant.both_infer += 1 } } println!("Ty interner total ty region both"); $(println!(" {:18}: {uses:6} {usespc:4.1}%, \ {ty:4.1}% {region:5.1}% {both:4.1}%", stringify!($variant), uses = $variant.total, usespc = $variant.total as f64 * 100.0 / total.total as f64, ty = $variant.ty_infer as f64 * 100.0 / total.total as f64, region = $variant.region_infer as f64 * 100.0 / total.total as f64, both = $variant.both_infer as f64 * 100.0 / total.total as f64); )* println!(" total {uses:6} \ {ty:4.1}% {region:5.1}% {both:4.1}%", uses = total.total, ty = total.ty_infer as f64 * 100.0 / total.total as f64, region = total.region_infer as f64 * 100.0 / total.total as f64, both = total.both_infer as f64 * 100.0 / total.total as f64) } } inner::go($ctxt) }} } impl<'tcx> ctxt<'tcx> { pub fn print_debug_stats(&self) { sty_debug_print!( self, ty_enum, ty_uniq, ty_vec, ty_ptr, ty_rptr, ty_bare_fn, ty_trait, ty_struct, ty_unboxed_closure, ty_tup, ty_param, ty_open, ty_infer, ty_projection); println!("Substs interner: #{}", self.substs_interner.borrow().len()); println!("BareFnTy interner: #{}", self.bare_fn_interner.borrow().len()); println!("Region interner: #{}", self.region_interner.borrow().len()); } } #[derive(Show)] pub struct TyS<'tcx> { pub sty: sty<'tcx>, pub flags: TypeFlags, // the maximal depth of any bound regions appearing in this type. region_depth: u32, } impl fmt::Show for TypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.bits) } } impl<'tcx> PartialEq for TyS<'tcx> { fn eq(&self, other: &TyS<'tcx>) -> bool { (self as *const _) == (other as *const _) } } impl<'tcx> Eq for TyS<'tcx> {} impl<'tcx, S: Writer> Hash for TyS<'tcx> { fn hash(&self, s: &mut S) { (self as *const _).hash(s) } } pub type Ty<'tcx> = &'tcx TyS<'tcx>; /// An entry in the type interner. pub struct InternedTy<'tcx> { ty: Ty<'tcx> } // NB: An InternedTy compares and hashes as a sty. impl<'tcx> PartialEq for InternedTy<'tcx> { fn eq(&self, other: &InternedTy<'tcx>) -> bool { self.ty.sty == other.ty.sty } } impl<'tcx> Eq for InternedTy<'tcx> {} impl<'tcx, S: Writer> Hash for InternedTy<'tcx> { fn hash(&self, s: &mut S) { self.ty.sty.hash(s) } } impl<'tcx> BorrowFrom> for sty<'tcx> { fn borrow_from<'a>(ty: &'a InternedTy<'tcx>) -> &'a sty<'tcx> { &ty.ty.sty } } pub fn type_has_params(ty: Ty) -> bool { ty.flags.intersects(HAS_PARAMS) } pub fn type_has_self(ty: Ty) -> bool { ty.flags.intersects(HAS_SELF) } pub fn type_has_ty_infer(ty: Ty) -> bool { ty.flags.intersects(HAS_TY_INFER) } pub fn type_needs_infer(ty: Ty) -> bool { ty.flags.intersects(HAS_TY_INFER | HAS_RE_INFER) } pub fn type_has_projection(ty: Ty) -> bool { ty.flags.intersects(HAS_PROJECTION) } pub fn type_has_late_bound_regions(ty: Ty) -> bool { ty.flags.intersects(HAS_RE_LATE_BOUND) } /// An "escaping region" is a bound region whose binder is not part of `t`. /// /// So, for example, consider a type like the following, which has two binders: /// /// for<'a> fn(x: for<'b> fn(&'a int, &'b int)) /// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ outer scope /// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ inner scope /// /// This type has *bound regions* (`'a`, `'b`), but it does not have escaping regions, because the /// binders of both `'a` and `'b` are part of the type itself. However, if we consider the *inner /// fn type*, that type has an escaping region: `'a`. /// /// Note that what I'm calling an "escaping region" is often just called a "free region". However, /// we already use the term "free region". It refers to the regions that we use to represent bound /// regions on a fn definition while we are typechecking its body. /// /// To clarify, conceptually there is no particular difference between an "escaping" region and a /// "free" region. However, there is a big difference in practice. Basically, when "entering" a /// binding level, one is generally required to do some sort of processing to a bound region, such /// as replacing it with a fresh/skolemized region, or making an entry in the environment to /// represent the scope to which it is attached, etc. An escaping region represents a bound region /// for which this processing has not yet been done. pub fn type_has_escaping_regions(ty: Ty) -> bool { type_escapes_depth(ty, 0) } pub fn type_escapes_depth(ty: Ty, depth: u32) -> bool { ty.region_depth > depth } #[derive(Clone, PartialEq, Eq, Hash, Show)] pub struct BareFnTy<'tcx> { pub unsafety: ast::Unsafety, pub abi: abi::Abi, pub sig: PolyFnSig<'tcx>, } #[derive(Clone, PartialEq, Eq, Hash, Show)] pub struct ClosureTy<'tcx> { pub unsafety: ast::Unsafety, pub onceness: ast::Onceness, pub store: TraitStore, pub bounds: ExistentialBounds<'tcx>, pub sig: PolyFnSig<'tcx>, pub abi: abi::Abi, } #[derive(Clone, Copy, PartialEq, Eq, Hash)] pub enum FnOutput<'tcx> { FnConverging(Ty<'tcx>), FnDiverging } impl<'tcx> FnOutput<'tcx> { pub fn unwrap(self) -> Ty<'tcx> { match self { ty::FnConverging(t) => t, ty::FnDiverging => unreachable!() } } } /// Signature of a function type, which I have arbitrarily /// decided to use to refer to the input/output types. /// /// - `inputs` is the list of arguments and their modes. /// - `output` is the return type. /// - `variadic` indicates whether this is a varidic function. (only true for foreign fns) #[derive(Clone, PartialEq, Eq, Hash)] pub struct FnSig<'tcx> { pub inputs: Vec>, pub output: FnOutput<'tcx>, pub variadic: bool } pub type PolyFnSig<'tcx> = Binder>; #[derive(Clone, Copy, PartialEq, Eq, Hash, Show)] pub struct ParamTy { pub space: subst::ParamSpace, pub idx: u32, pub name: ast::Name, } /// A [De Bruijn index][dbi] is a standard means of representing /// regions (and perhaps later types) in a higher-ranked setting. In /// particular, imagine a type like this: /// /// for<'a> fn(for<'b> fn(&'b int, &'a int), &'a char) /// ^ ^ | | | /// | | | | | /// | +------------+ 1 | | /// | | | /// +--------------------------------+ 2 | /// | | /// +------------------------------------------+ 1 /// /// In this type, there are two binders (the outer fn and the inner /// fn). We need to be able to determine, for any given region, which /// fn type it is bound by, the inner or the outer one. There are /// various ways you can do this, but a De Bruijn index is one of the /// more convenient and has some nice properties. The basic idea is to /// count the number of binders, inside out. Some examples should help /// clarify what I mean. /// /// Let's start with the reference type `&'b int` that is the first /// argument to the inner function. This region `'b` is assigned a De /// Bruijn index of 1, meaning "the innermost binder" (in this case, a /// fn). The region `'a` that appears in the second argument type (`&'a /// int`) would then be assigned a De Bruijn index of 2, meaning "the /// second-innermost binder". (These indices are written on the arrays /// in the diagram). /// /// What is interesting is that De Bruijn index attached to a particular /// variable will vary depending on where it appears. For example, /// the final type `&'a char` also refers to the region `'a` declared on /// the outermost fn. But this time, this reference is not nested within /// any other binders (i.e., it is not an argument to the inner fn, but /// rather the outer one). Therefore, in this case, it is assigned a /// De Bruijn index of 1, because the innermost binder in that location /// is the outer fn. /// /// [dbi]: http://en.wikipedia.org/wiki/De_Bruijn_index #[derive(Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Show, Copy)] pub struct DebruijnIndex { // We maintain the invariant that this is never 0. So 1 indicates // the innermost binder. To ensure this, create with `DebruijnIndex::new`. pub depth: u32, } /// Representation of regions: #[derive(Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Show, Copy)] pub enum Region { // Region bound in a type or fn declaration which will be // substituted 'early' -- that is, at the same time when type // parameters are substituted. ReEarlyBound(/* param id */ ast::NodeId, subst::ParamSpace, /*index*/ u32, ast::Name), // Region bound in a function scope, which will be substituted when the // function is called. ReLateBound(DebruijnIndex, BoundRegion), /// When checking a function body, the types of all arguments and so forth /// that refer to bound region parameters are modified to refer to free /// region parameters. ReFree(FreeRegion), /// A concrete region naming some expression within the current function. ReScope(region::CodeExtent), /// Static data that has an "infinite" lifetime. Top in the region lattice. ReStatic, /// A region variable. Should not exist after typeck. ReInfer(InferRegion), /// Empty lifetime is for data that is never accessed. /// Bottom in the region lattice. We treat ReEmpty somewhat /// specially; at least right now, we do not generate instances of /// it during the GLB computations, but rather /// generate an error instead. This is to improve error messages. /// The only way to get an instance of ReEmpty is to have a region /// variable with no constraints. ReEmpty, } /// Upvars do not get their own node-id. Instead, we use the pair of /// the original var id (that is, the root variable that is referenced /// by the upvar) and the id of the closure expression. #[derive(Clone, Copy, PartialEq, Eq, Hash, Show)] pub struct UpvarId { pub var_id: ast::NodeId, pub closure_expr_id: ast::NodeId, } #[derive(Clone, PartialEq, Eq, Hash, Show, RustcEncodable, RustcDecodable, Copy)] pub enum BorrowKind { /// Data must be immutable and is aliasable. ImmBorrow, /// Data must be immutable but not aliasable. This kind of borrow /// cannot currently be expressed by the user and is used only in /// implicit closure bindings. It is needed when you the closure /// is borrowing or mutating a mutable referent, e.g.: /// /// let x: &mut int = ...; /// let y = || *x += 5; /// /// If we were to try to translate this closure into a more explicit /// form, we'd encounter an error with the code as written: /// /// struct Env { x: & &mut int } /// let x: &mut int = ...; /// let y = (&mut Env { &x }, fn_ptr); // Closure is pair of env and fn /// fn fn_ptr(env: &mut Env) { **env.x += 5; } /// /// This is then illegal because you cannot mutate a `&mut` found /// in an aliasable location. To solve, you'd have to translate with /// an `&mut` borrow: /// /// struct Env { x: & &mut int } /// let x: &mut int = ...; /// let y = (&mut Env { &mut x }, fn_ptr); // changed from &x to &mut x /// fn fn_ptr(env: &mut Env) { **env.x += 5; } /// /// Now the assignment to `**env.x` is legal, but creating a /// mutable pointer to `x` is not because `x` is not mutable. We /// could fix this by declaring `x` as `let mut x`. This is ok in /// user code, if awkward, but extra weird for closures, since the /// borrow is hidden. /// /// So we introduce a "unique imm" borrow -- the referent is /// immutable, but not aliasable. This solves the problem. For /// simplicity, we don't give users the way to express this /// borrow, it's just used when translating closures. UniqueImmBorrow, /// Data is mutable and not aliasable. MutBorrow } /// Information describing the borrowing of an upvar. This is computed /// during `typeck`, specifically by `regionck`. The general idea is /// that the compiler analyses treat closures like: /// /// let closure: &'e fn() = || { /// x = 1; // upvar x is assigned to /// use(y); // upvar y is read /// foo(&z); // upvar z is borrowed immutably /// }; /// /// as if they were "desugared" to something loosely like: /// /// struct Vars<'x,'y,'z> { x: &'x mut int, /// y: &'y const int, /// z: &'z int } /// let closure: &'e fn() = { /// fn f(env: &Vars) { /// *env.x = 1; /// use(*env.y); /// foo(env.z); /// } /// let env: &'e mut Vars<'x,'y,'z> = &mut Vars { x: &'x mut x, /// y: &'y const y, /// z: &'z z }; /// (env, f) /// }; /// /// This is basically what happens at runtime. The closure is basically /// an existentially quantified version of the `(env, f)` pair. /// /// This data structure indicates the region and mutability of a single /// one of the `x...z` borrows. /// /// It may not be obvious why each borrowed variable gets its own /// lifetime (in the desugared version of the example, these are indicated /// by the lifetime parameters `'x`, `'y`, and `'z` in the `Vars` definition). /// Each such lifetime must encompass the lifetime `'e` of the closure itself, /// but need not be identical to it. The reason that this makes sense: /// /// - Callers are only permitted to invoke the closure, and hence to /// use the pointers, within the lifetime `'e`, so clearly `'e` must /// be a sublifetime of `'x...'z`. /// - The closure creator knows which upvars were borrowed by the closure /// and thus `x...z` will be reserved for `'x...'z` respectively. /// - Through mutation, the borrowed upvars can actually escape /// the closure, so sometimes it is necessary for them to be larger /// than the closure lifetime itself. #[derive(PartialEq, Clone, RustcEncodable, RustcDecodable, Show, Copy)] pub struct UpvarBorrow { pub kind: BorrowKind, pub region: ty::Region, } pub type UpvarBorrowMap = FnvHashMap; impl Region { pub fn is_bound(&self) -> bool { match *self { ty::ReEarlyBound(..) => true, ty::ReLateBound(..) => true, _ => false } } pub fn escapes_depth(&self, depth: u32) -> bool { match *self { ty::ReLateBound(debruijn, _) => debruijn.depth > depth, _ => false, } } } #[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, RustcEncodable, RustcDecodable, Show, Copy)] /// A "free" region `fr` can be interpreted as "some region /// at least as big as the scope `fr.scope`". pub struct FreeRegion { pub scope: region::CodeExtent, pub bound_region: BoundRegion } #[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, RustcEncodable, RustcDecodable, Show, Copy)] pub enum BoundRegion { /// An anonymous region parameter for a given fn (&T) BrAnon(u32), /// Named region parameters for functions (a in &'a T) /// /// The def-id is needed to distinguish free regions in /// the event of shadowing. BrNamed(ast::DefId, ast::Name), /// Fresh bound identifiers created during GLB computations. BrFresh(u32), // Anonymous region for the implicit env pointer parameter // to a closure BrEnv } // NB: If you change this, you'll probably want to change the corresponding // AST structure in libsyntax/ast.rs as well. #[derive(Clone, PartialEq, Eq, Hash, Show)] pub enum sty<'tcx> { ty_bool, ty_char, ty_int(ast::IntTy), ty_uint(ast::UintTy), ty_float(ast::FloatTy), /// Substs here, possibly against intuition, *may* contain `ty_param`s. /// That is, even after substitution it is possible that there are type /// variables. This happens when the `ty_enum` corresponds to an enum /// definition and not a concrete use of it. To get the correct `ty_enum` /// from the tcx, use the `NodeId` from the `ast::Ty` and look it up in /// the `ast_ty_to_ty_cache`. This is probably true for `ty_struct` as /// well.` ty_enum(DefId, &'tcx Substs<'tcx>), ty_uniq(Ty<'tcx>), ty_str, ty_vec(Ty<'tcx>, Option), // Second field is length. ty_ptr(mt<'tcx>), ty_rptr(&'tcx Region, mt<'tcx>), // If the def-id is Some(_), then this is the type of a specific // fn item. Otherwise, if None(_), it a fn pointer type. ty_bare_fn(Option, &'tcx BareFnTy<'tcx>), ty_trait(Box>), ty_struct(DefId, &'tcx Substs<'tcx>), ty_unboxed_closure(DefId, &'tcx Region, &'tcx Substs<'tcx>), ty_tup(Vec>), ty_projection(ProjectionTy<'tcx>), ty_param(ParamTy), // type parameter ty_open(Ty<'tcx>), // A deref'ed fat pointer, i.e., a dynamically sized value // and its size. Only ever used in trans. It is not necessary // earlier since we don't need to distinguish a DST with its // size (e.g., in a deref) vs a DST with the size elsewhere ( // e.g., in a field). ty_infer(InferTy), // something used only during inference/typeck ty_err, // Also only used during inference/typeck, to represent // the type of an erroneous expression (helps cut down // on non-useful type error messages) } #[derive(Clone, PartialEq, Eq, Hash, Show)] pub struct TyTrait<'tcx> { pub principal: ty::PolyTraitRef<'tcx>, pub bounds: ExistentialBounds<'tcx>, } impl<'tcx> TyTrait<'tcx> { pub fn principal_def_id(&self) -> ast::DefId { self.principal.0.def_id } /// Object types don't have a self-type specified. Therefore, when /// we convert the principal trait-ref into a normal trait-ref, /// you must give *some* self-type. A common choice is `mk_err()` /// or some skolemized type. pub fn principal_trait_ref_with_self_ty(&self, tcx: &ctxt<'tcx>, self_ty: Ty<'tcx>) -> ty::PolyTraitRef<'tcx> { // otherwise the escaping regions would be captured by the binder assert!(!self_ty.has_escaping_regions()); ty::Binder(Rc::new(ty::TraitRef { def_id: self.principal.0.def_id, substs: tcx.mk_substs(self.principal.0.substs.with_self_ty(self_ty)), })) } pub fn projection_bounds_with_self_ty(&self, tcx: &ctxt<'tcx>, self_ty: Ty<'tcx>) -> Vec> { // otherwise the escaping regions would be captured by the binders assert!(!self_ty.has_escaping_regions()); self.bounds.projection_bounds.iter() .map(|in_poly_projection_predicate| { let in_projection_ty = &in_poly_projection_predicate.0.projection_ty; let substs = tcx.mk_substs(in_projection_ty.trait_ref.substs.with_self_ty(self_ty)); let trait_ref = Rc::new(ty::TraitRef::new(in_projection_ty.trait_ref.def_id, substs)); let projection_ty = ty::ProjectionTy { trait_ref: trait_ref, item_name: in_projection_ty.item_name }; ty::Binder(ty::ProjectionPredicate { projection_ty: projection_ty, ty: in_poly_projection_predicate.0.ty }) }) .collect() } } /// A complete reference to a trait. These take numerous guises in syntax, /// but perhaps the most recognizable form is in a where clause: /// /// T : Foo /// /// This would be represented by a trait-reference where the def-id is the /// def-id for the trait `Foo` and the substs defines `T` as parameter 0 in the /// `SelfSpace` and `U` as parameter 0 in the `TypeSpace`. /// /// Trait references also appear in object types like `Foo`, but in /// that case the `Self` parameter is absent from the substitutions. /// /// Note that a `TraitRef` introduces a level of region binding, to /// account for higher-ranked trait bounds like `T : for<'a> Foo<&'a /// U>` or higher-ranked object types. #[derive(Clone, PartialEq, Eq, Hash, Show)] pub struct TraitRef<'tcx> { pub def_id: DefId, pub substs: &'tcx Substs<'tcx>, } pub type PolyTraitRef<'tcx> = Binder>>; impl<'tcx> PolyTraitRef<'tcx> { pub fn self_ty(&self) -> Ty<'tcx> { self.0.self_ty() } pub fn def_id(&self) -> ast::DefId { self.0.def_id } pub fn substs(&self) -> &'tcx Substs<'tcx> { self.0.substs } pub fn input_types(&self) -> &[Ty<'tcx>] { self.0.input_types() } pub fn to_poly_trait_predicate(&self) -> PolyTraitPredicate<'tcx> { // Note that we preserve binding levels Binder(TraitPredicate { trait_ref: self.0.clone() }) } } /// Binder is a binder for higher-ranked lifetimes. It is part of the /// compiler's representation for things like `for<'a> Fn(&'a int)` /// (which would be represented by the type `PolyTraitRef == /// Binder`). Note that when we skolemize, instantiate, /// erase, or otherwise "discharge" these bound reons, we change the /// type from `Binder` to just `T` (see /// e.g. `liberate_late_bound_regions`). #[derive(Clone, PartialEq, Eq, Hash, Show)] pub struct Binder(pub T); #[derive(Clone, Copy, PartialEq)] pub enum IntVarValue { IntType(ast::IntTy), UintType(ast::UintTy), } #[derive(Clone, Copy, Show)] pub enum terr_vstore_kind { terr_vec, terr_str, terr_fn, terr_trait } #[derive(Clone, Copy, Show)] pub struct expected_found { pub expected: T, pub found: T } // Data structures used in type unification #[derive(Clone, Copy, Show)] pub enum type_err<'tcx> { terr_mismatch, terr_unsafety_mismatch(expected_found), terr_onceness_mismatch(expected_found), terr_abi_mismatch(expected_found), terr_mutability, terr_sigil_mismatch(expected_found), terr_box_mutability, terr_ptr_mutability, terr_ref_mutability, terr_vec_mutability, terr_tuple_size(expected_found), terr_fixed_array_size(expected_found), terr_ty_param_size(expected_found), terr_arg_count, terr_regions_does_not_outlive(Region, Region), terr_regions_not_same(Region, Region), terr_regions_no_overlap(Region, Region), terr_regions_insufficiently_polymorphic(BoundRegion, Region), terr_regions_overly_polymorphic(BoundRegion, Region), terr_trait_stores_differ(terr_vstore_kind, expected_found), terr_sorts(expected_found>), terr_integer_as_char, terr_int_mismatch(expected_found), terr_float_mismatch(expected_found), terr_traits(expected_found), terr_builtin_bounds(expected_found), terr_variadic_mismatch(expected_found), terr_cyclic_ty, terr_convergence_mismatch(expected_found), terr_projection_name_mismatched(expected_found), terr_projection_bounds_length(expected_found), } /// Bounds suitable for a named type parameter like `A` in `fn foo` /// as well as the existential type parameter in an object type. #[derive(PartialEq, Eq, Hash, Clone, Show)] pub struct ParamBounds<'tcx> { pub region_bounds: Vec, pub builtin_bounds: BuiltinBounds, pub trait_bounds: Vec>, pub projection_bounds: Vec>, } /// Bounds suitable for an existentially quantified type parameter /// such as those that appear in object types or closure types. The /// major difference between this case and `ParamBounds` is that /// general purpose trait bounds are omitted and there must be /// *exactly one* region. #[derive(PartialEq, Eq, Hash, Clone, Show)] pub struct ExistentialBounds<'tcx> { pub region_bound: ty::Region, pub builtin_bounds: BuiltinBounds, pub projection_bounds: Vec>, } pub type BuiltinBounds = EnumSet; #[derive(Clone, RustcEncodable, PartialEq, Eq, RustcDecodable, Hash, Show, Copy)] #[repr(uint)] pub enum BuiltinBound { BoundSend, BoundSized, BoundCopy, BoundSync, } pub fn empty_builtin_bounds() -> BuiltinBounds { EnumSet::new() } pub fn all_builtin_bounds() -> BuiltinBounds { let mut set = EnumSet::new(); set.insert(BoundSend); set.insert(BoundSized); set.insert(BoundSync); set } /// An existential bound that does not implement any traits. pub fn region_existential_bound<'tcx>(r: ty::Region) -> ExistentialBounds<'tcx> { ty::ExistentialBounds { region_bound: r, builtin_bounds: empty_builtin_bounds(), projection_bounds: Vec::new() } } impl CLike for BuiltinBound { fn to_uint(&self) -> uint { *self as uint } fn from_uint(v: uint) -> BuiltinBound { unsafe { mem::transmute(v) } } } #[derive(Clone, Copy, PartialEq, Eq, Hash)] pub struct TyVid { pub index: u32 } #[derive(Clone, Copy, PartialEq, Eq, Hash)] pub struct IntVid { pub index: u32 } #[derive(Clone, Copy, PartialEq, Eq, Hash)] pub struct FloatVid { pub index: u32 } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] pub struct RegionVid { pub index: u32 } #[derive(Clone, Copy, PartialEq, Eq, Hash)] pub enum InferTy { TyVar(TyVid), IntVar(IntVid), FloatVar(FloatVid), /// A `FreshTy` is one that is generated as a replacement for an /// unbound type variable. This is convenient for caching etc. See /// `middle::infer::freshen` for more details. FreshTy(u32), // FIXME -- once integral fallback is impl'd, we should remove // this type. It's only needed to prevent spurious errors for // integers whose type winds up never being constrained. FreshIntTy(u32), } #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Show, Copy)] pub enum UnconstrainedNumeric { UnconstrainedFloat, UnconstrainedInt, Neither, } #[derive(Clone, RustcEncodable, RustcDecodable, Eq, Hash, Show, Copy)] pub enum InferRegion { ReVar(RegionVid), ReSkolemized(u32, BoundRegion) } impl cmp::PartialEq for InferRegion { fn eq(&self, other: &InferRegion) -> bool { match ((*self), *other) { (ReVar(rva), ReVar(rvb)) => { rva == rvb } (ReSkolemized(rva, _), ReSkolemized(rvb, _)) => { rva == rvb } _ => false } } fn ne(&self, other: &InferRegion) -> bool { !((*self) == (*other)) } } impl fmt::Show for TyVid { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{ write!(f, "_#{}t", self.index) } } impl fmt::Show for IntVid { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "_#{}i", self.index) } } impl fmt::Show for FloatVid { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "_#{}f", self.index) } } impl fmt::Show for RegionVid { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "'_#{}r", self.index) } } impl<'tcx> fmt::Show for FnSig<'tcx> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // grr, without tcx not much we can do. write!(f, "(...)") } } impl fmt::Show for InferTy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { TyVar(ref v) => v.fmt(f), IntVar(ref v) => v.fmt(f), FloatVar(ref v) => v.fmt(f), FreshTy(v) => write!(f, "FreshTy({})", v), FreshIntTy(v) => write!(f, "FreshIntTy({})", v), } } } impl fmt::Show for IntVarValue { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { IntType(ref v) => v.fmt(f), UintType(ref v) => v.fmt(f), } } } #[derive(Clone, Show)] pub struct TypeParameterDef<'tcx> { pub name: ast::Name, pub def_id: ast::DefId, pub space: subst::ParamSpace, pub index: u32, pub bounds: ParamBounds<'tcx>, pub default: Option>, } #[derive(RustcEncodable, RustcDecodable, Clone, Show)] pub struct RegionParameterDef { pub name: ast::Name, pub def_id: ast::DefId, pub space: subst::ParamSpace, pub index: u32, pub bounds: Vec, } impl RegionParameterDef { pub fn to_early_bound_region(&self) -> ty::Region { ty::ReEarlyBound(self.def_id.node, self.space, self.index, self.name) } } /// Information about the formal type/lifetime parameters associated /// with an item or method. Analogous to ast::Generics. #[derive(Clone, Show)] pub struct Generics<'tcx> { pub types: VecPerParamSpace>, pub regions: VecPerParamSpace, pub predicates: VecPerParamSpace>, } impl<'tcx> Generics<'tcx> { pub fn empty() -> Generics<'tcx> { Generics { types: VecPerParamSpace::empty(), regions: VecPerParamSpace::empty(), predicates: VecPerParamSpace::empty(), } } pub fn has_type_params(&self, space: subst::ParamSpace) -> bool { !self.types.is_empty_in(space) } pub fn has_region_params(&self, space: subst::ParamSpace) -> bool { !self.regions.is_empty_in(space) } pub fn is_empty(&self) -> bool { self.types.is_empty() && self.regions.is_empty() } pub fn to_bounds(&self, tcx: &ty::ctxt<'tcx>, substs: &Substs<'tcx>) -> GenericBounds<'tcx> { GenericBounds { predicates: self.predicates.subst(tcx, substs), } } } #[derive(Clone, PartialEq, Eq, Hash, Show)] pub enum Predicate<'tcx> { /// Corresponds to `where Foo : Bar`. `Foo` here would be /// the `Self` type of the trait reference and `A`, `B`, and `C` /// would be the parameters in the `TypeSpace`. Trait(PolyTraitPredicate<'tcx>), /// where `T1 == T2`. Equate(PolyEquatePredicate<'tcx>), /// where 'a : 'b RegionOutlives(PolyRegionOutlivesPredicate), /// where T : 'a TypeOutlives(PolyTypeOutlivesPredicate<'tcx>), /// where ::Name == X, approximately. /// See `ProjectionPredicate` struct for details. Projection(PolyProjectionPredicate<'tcx>), } #[derive(Clone, PartialEq, Eq, Hash, Show)] pub struct TraitPredicate<'tcx> { pub trait_ref: Rc> } pub type PolyTraitPredicate<'tcx> = ty::Binder>; impl<'tcx> TraitPredicate<'tcx> { pub fn def_id(&self) -> ast::DefId { self.trait_ref.def_id } pub fn input_types(&self) -> &[Ty<'tcx>] { self.trait_ref.substs.types.as_slice() } pub fn self_ty(&self) -> Ty<'tcx> { self.trait_ref.self_ty() } } impl<'tcx> PolyTraitPredicate<'tcx> { pub fn def_id(&self) -> ast::DefId { self.0.def_id() } } #[derive(Clone, PartialEq, Eq, Hash, Show)] pub struct EquatePredicate<'tcx>(pub Ty<'tcx>, pub Ty<'tcx>); // `0 == 1` pub type PolyEquatePredicate<'tcx> = ty::Binder>; #[derive(Clone, PartialEq, Eq, Hash, Show)] pub struct OutlivesPredicate(pub A, pub B); // `A : B` pub type PolyOutlivesPredicate = ty::Binder>; pub type PolyRegionOutlivesPredicate = PolyOutlivesPredicate; pub type PolyTypeOutlivesPredicate<'tcx> = PolyOutlivesPredicate, ty::Region>; /// This kind of predicate has no *direct* correspondent in the /// syntax, but it roughly corresponds to the syntactic forms: /// /// 1. `T : TraitRef<..., Item=Type>` /// 2. `>::Item == Type` (NYI) /// /// In particular, form #1 is "desugared" to the combination of a /// normal trait predicate (`T : TraitRef<...>`) and one of these /// predicates. Form #2 is a broader form in that it also permits /// equality between arbitrary types. Processing an instance of Form /// #2 eventually yields one of these `ProjectionPredicate` /// instances to normalize the LHS. #[derive(Clone, PartialEq, Eq, Hash, Show)] pub struct ProjectionPredicate<'tcx> { pub projection_ty: ProjectionTy<'tcx>, pub ty: Ty<'tcx>, } pub type PolyProjectionPredicate<'tcx> = Binder>; impl<'tcx> PolyProjectionPredicate<'tcx> { pub fn sort_key(&self) -> (ast::DefId, ast::Name) { self.0.projection_ty.sort_key() } } /// Represents the projection of an associated type. In explicit UFCS /// form this would be written `>::N`. #[derive(Clone, PartialEq, Eq, Hash, Show)] pub struct ProjectionTy<'tcx> { /// The trait reference `T as Trait<..>`. pub trait_ref: Rc>, /// The name `N` of the associated type. pub item_name: ast::Name, } impl<'tcx> ProjectionTy<'tcx> { pub fn sort_key(&self) -> (ast::DefId, ast::Name) { (self.trait_ref.def_id, self.item_name) } } pub trait ToPolyTraitRef<'tcx> { fn to_poly_trait_ref(&self) -> PolyTraitRef<'tcx>; } impl<'tcx> ToPolyTraitRef<'tcx> for Rc> { fn to_poly_trait_ref(&self) -> PolyTraitRef<'tcx> { assert!(!self.has_escaping_regions()); ty::Binder(self.clone()) } } impl<'tcx> ToPolyTraitRef<'tcx> for PolyTraitPredicate<'tcx> { fn to_poly_trait_ref(&self) -> PolyTraitRef<'tcx> { // We are just preserving the binder levels here ty::Binder(self.0.trait_ref.clone()) } } impl<'tcx> ToPolyTraitRef<'tcx> for PolyProjectionPredicate<'tcx> { fn to_poly_trait_ref(&self) -> PolyTraitRef<'tcx> { // Note: unlike with TraitRef::to_poly_trait_ref(), // self.0.trait_ref is permitted to have escaping regions. // This is because here `self` has a `Binder` and so does our // return value, so we are preserving the number of binding // levels. ty::Binder(self.0.projection_ty.trait_ref.clone()) } } pub trait AsPredicate<'tcx> { fn as_predicate(&self) -> Predicate<'tcx>; } impl<'tcx> AsPredicate<'tcx> for Rc> { fn as_predicate(&self) -> Predicate<'tcx> { // we're about to add a binder, so let's check that we don't // accidentally capture anything, or else that might be some // weird debruijn accounting. assert!(!self.has_escaping_regions()); ty::Predicate::Trait(ty::Binder(ty::TraitPredicate { trait_ref: self.clone() })) } } impl<'tcx> AsPredicate<'tcx> for PolyTraitRef<'tcx> { fn as_predicate(&self) -> Predicate<'tcx> { ty::Predicate::Trait(self.to_poly_trait_predicate()) } } impl<'tcx> AsPredicate<'tcx> for PolyEquatePredicate<'tcx> { fn as_predicate(&self) -> Predicate<'tcx> { Predicate::Equate(self.clone()) } } impl<'tcx> AsPredicate<'tcx> for PolyRegionOutlivesPredicate { fn as_predicate(&self) -> Predicate<'tcx> { Predicate::RegionOutlives(self.clone()) } } impl<'tcx> AsPredicate<'tcx> for PolyTypeOutlivesPredicate<'tcx> { fn as_predicate(&self) -> Predicate<'tcx> { Predicate::TypeOutlives(self.clone()) } } impl<'tcx> AsPredicate<'tcx> for PolyProjectionPredicate<'tcx> { fn as_predicate(&self) -> Predicate<'tcx> { Predicate::Projection(self.clone()) } } impl<'tcx> Predicate<'tcx> { pub fn has_escaping_regions(&self) -> bool { match *self { Predicate::Trait(ref trait_ref) => trait_ref.has_escaping_regions(), Predicate::Equate(ref p) => p.has_escaping_regions(), Predicate::RegionOutlives(ref p) => p.has_escaping_regions(), Predicate::TypeOutlives(ref p) => p.has_escaping_regions(), Predicate::Projection(ref p) => p.has_escaping_regions(), } } pub fn to_opt_poly_trait_ref(&self) -> Option> { match *self { Predicate::Trait(ref t) => { Some(t.to_poly_trait_ref()) } Predicate::Projection(..) | Predicate::Equate(..) | Predicate::RegionOutlives(..) | Predicate::TypeOutlives(..) => { None } } } } /// Represents the bounds declared on a particular set of type /// parameters. Should eventually be generalized into a flag list of /// where clauses. You can obtain a `GenericBounds` list from a /// `Generics` by using the `to_bounds` method. Note that this method /// reflects an important semantic invariant of `GenericBounds`: while /// the bounds in a `Generics` are expressed in terms of the bound type /// parameters of the impl/trait/whatever, a `GenericBounds` instance /// represented a set of bounds for some particular instantiation, /// meaning that the generic parameters have been substituted with /// their values. /// /// Example: /// /// struct Foo> { ... } /// /// Here, the `Generics` for `Foo` would contain a list of bounds like /// `[[], [U:Bar]]`. Now if there were some particular reference /// like `Foo`, then the `GenericBounds` would be `[[], /// [uint:Bar]]`. #[derive(Clone, Show)] pub struct GenericBounds<'tcx> { pub predicates: VecPerParamSpace>, } impl<'tcx> GenericBounds<'tcx> { pub fn empty() -> GenericBounds<'tcx> { GenericBounds { predicates: VecPerParamSpace::empty() } } pub fn has_escaping_regions(&self) -> bool { self.predicates.any(|p| p.has_escaping_regions()) } pub fn is_empty(&self) -> bool { self.predicates.is_empty() } } impl<'tcx> TraitRef<'tcx> { pub fn new(def_id: ast::DefId, substs: &'tcx Substs<'tcx>) -> TraitRef<'tcx> { TraitRef { def_id: def_id, substs: substs } } pub fn self_ty(&self) -> Ty<'tcx> { self.substs.self_ty().unwrap() } pub fn input_types(&self) -> &[Ty<'tcx>] { // Select only the "input types" from a trait-reference. For // now this is all the types that appear in the // trait-reference, but it should eventually exclude // associated types. self.substs.types.as_slice() } } /// When type checking, we use the `ParameterEnvironment` to track /// details about the type/lifetime parameters that are in scope. /// It primarily stores the bounds information. /// /// Note: This information might seem to be redundant with the data in /// `tcx.ty_param_defs`, but it is not. That table contains the /// parameter definitions from an "outside" perspective, but this /// struct will contain the bounds for a parameter as seen from inside /// the function body. Currently the only real distinction is that /// bound lifetime parameters are replaced with free ones, but in the /// future I hope to refine the representation of types so as to make /// more distinctions clearer. #[derive(Clone)] pub struct ParameterEnvironment<'a, 'tcx:'a> { pub tcx: &'a ctxt<'tcx>, /// A substitution that can be applied to move from /// the "outer" view of a type or method to the "inner" view. /// In general, this means converting from bound parameters to /// free parameters. Since we currently represent bound/free type /// parameters in the same way, this only has an effect on regions. pub free_substs: Substs<'tcx>, /// Each type parameter has an implicit region bound that /// indicates it must outlive at least the function body (the user /// may specify stronger requirements). This field indicates the /// region of the callee. pub implicit_region_bound: ty::Region, /// Obligations that the caller must satisfy. This is basically /// the set of bounds on the in-scope type parameters, translated /// into Obligations. pub caller_bounds: ty::GenericBounds<'tcx>, /// Caches the results of trait selection. This cache is used /// for things that have to do with the parameters in scope. pub selection_cache: traits::SelectionCache<'tcx>, } impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { pub fn for_item(cx: &'a ctxt<'tcx>, id: NodeId) -> ParameterEnvironment<'a, 'tcx> { match cx.map.find(id) { Some(ast_map::NodeImplItem(ref impl_item)) => { match **impl_item { ast::MethodImplItem(ref method) => { let method_def_id = ast_util::local_def(id); match ty::impl_or_trait_item(cx, method_def_id) { MethodTraitItem(ref method_ty) => { let method_generics = &method_ty.generics; construct_parameter_environment( cx, method_generics, method.pe_body().id) } TypeTraitItem(_) => { cx.sess .bug("ParameterEnvironment::for_item(): \ can't create a parameter environment \ for type trait items") } } } ast::TypeImplItem(_) => { cx.sess.bug("ParameterEnvironment::for_item(): \ can't create a parameter environment \ for type impl items") } } } Some(ast_map::NodeTraitItem(trait_method)) => { match *trait_method { ast::RequiredMethod(ref required) => { cx.sess.span_bug(required.span, "ParameterEnvironment::for_item(): can't create a parameter \ environment for required trait \ methods") } ast::ProvidedMethod(ref method) => { let method_def_id = ast_util::local_def(id); match ty::impl_or_trait_item(cx, method_def_id) { MethodTraitItem(ref method_ty) => { let method_generics = &method_ty.generics; construct_parameter_environment( cx, method_generics, method.pe_body().id) } TypeTraitItem(_) => { cx.sess .bug("ParameterEnvironment::for_item(): \ can't create a parameter environment \ for type trait items") } } } ast::TypeTraitItem(_) => { cx.sess.bug("ParameterEnvironment::from_item(): \ can't create a parameter environment \ for type trait items") } } } Some(ast_map::NodeItem(item)) => { match item.node { ast::ItemFn(_, _, _, _, ref body) => { // We assume this is a function. let fn_def_id = ast_util::local_def(id); let fn_pty = ty::lookup_item_type(cx, fn_def_id); construct_parameter_environment(cx, &fn_pty.generics, body.id) } ast::ItemEnum(..) | ast::ItemStruct(..) | ast::ItemImpl(..) | ast::ItemConst(..) | ast::ItemStatic(..) => { let def_id = ast_util::local_def(id); let pty = ty::lookup_item_type(cx, def_id); construct_parameter_environment(cx, &pty.generics, id) } _ => { cx.sess.span_bug(item.span, "ParameterEnvironment::from_item(): can't create a parameter \ environment for this kind of item") } } } Some(ast_map::NodeExpr(..)) => { // This is a convenience to allow closures to work. ParameterEnvironment::for_item(cx, cx.map.get_parent(id)) } _ => { cx.sess.bug(format!("ParameterEnvironment::from_item(): \ `{}` is not an item", cx.map.node_to_string(id))[]) } } } } /// A "type scheme", in ML terminology, is a type combined with some /// set of generic types that the type is, well, generic over. In Rust /// terms, it is the "type" of a fn item or struct -- this type will /// include various generic parameters that must be substituted when /// the item/struct is referenced. That is called converting the type /// scheme to a monotype. /// /// - `generics`: the set of type parameters and their bounds /// - `ty`: the base types, which may reference the parameters defined /// in `generics` /// /// Note that TypeSchemes are also sometimes called "polytypes" (and /// in fact this struct used to carry that name, so you may find some /// stray references in a comment or something). We try to reserve the /// "poly" prefix to refer to higher-ranked things, as in /// `PolyTraitRef`. #[derive(Clone, Show)] pub struct TypeScheme<'tcx> { pub generics: Generics<'tcx>, pub ty: Ty<'tcx> } /// As `TypeScheme` but for a trait ref. pub struct TraitDef<'tcx> { pub unsafety: ast::Unsafety, /// Generic type definitions. Note that `Self` is listed in here /// as having a single bound, the trait itself (e.g., in the trait /// `Eq`, there is a single bound `Self : Eq`). This is so that /// default methods get to assume that the `Self` parameters /// implements the trait. pub generics: Generics<'tcx>, /// The "supertrait" bounds. pub bounds: ParamBounds<'tcx>, pub trait_ref: Rc>, /// A list of the associated types defined in this trait. Useful /// for resolving `X::Foo` type markers. pub associated_type_names: Vec, } /// Records the substitutions used to translate the polytype for an /// item into the monotype of an item reference. #[derive(Clone)] pub struct ItemSubsts<'tcx> { pub substs: Substs<'tcx>, } /// Records information about each unboxed closure. #[derive(Clone)] pub struct UnboxedClosure<'tcx> { /// The type of the unboxed closure. pub closure_type: ClosureTy<'tcx>, /// The kind of unboxed closure this is. pub kind: UnboxedClosureKind, } #[derive(Clone, Copy, PartialEq, Eq, Show)] pub enum UnboxedClosureKind { FnUnboxedClosureKind, FnMutUnboxedClosureKind, FnOnceUnboxedClosureKind, } impl UnboxedClosureKind { pub fn trait_did(&self, cx: &ctxt) -> ast::DefId { let result = match *self { FnUnboxedClosureKind => cx.lang_items.require(FnTraitLangItem), FnMutUnboxedClosureKind => { cx.lang_items.require(FnMutTraitLangItem) } FnOnceUnboxedClosureKind => { cx.lang_items.require(FnOnceTraitLangItem) } }; match result { Ok(trait_did) => trait_did, Err(err) => cx.sess.fatal(err[]), } } } pub trait UnboxedClosureTyper<'tcx> { fn param_env<'a>(&'a self) -> &'a ty::ParameterEnvironment<'a, 'tcx>; fn unboxed_closure_kind(&self, def_id: ast::DefId) -> ty::UnboxedClosureKind; fn unboxed_closure_type(&self, def_id: ast::DefId, substs: &subst::Substs<'tcx>) -> ty::ClosureTy<'tcx>; // Returns `None` if the upvar types cannot yet be definitively determined. fn unboxed_closure_upvars(&self, def_id: ast::DefId, substs: &Substs<'tcx>) -> Option>>; } impl<'tcx> CommonTypes<'tcx> { fn new(arena: &'tcx TypedArena>, interner: &mut FnvHashMap, Ty<'tcx>>) -> CommonTypes<'tcx> { CommonTypes { bool: intern_ty(arena, interner, ty_bool), char: intern_ty(arena, interner, ty_char), err: intern_ty(arena, interner, ty_err), int: intern_ty(arena, interner, ty_int(ast::TyI)), i8: intern_ty(arena, interner, ty_int(ast::TyI8)), i16: intern_ty(arena, interner, ty_int(ast::TyI16)), i32: intern_ty(arena, interner, ty_int(ast::TyI32)), i64: intern_ty(arena, interner, ty_int(ast::TyI64)), uint: intern_ty(arena, interner, ty_uint(ast::TyU)), u8: intern_ty(arena, interner, ty_uint(ast::TyU8)), u16: intern_ty(arena, interner, ty_uint(ast::TyU16)), u32: intern_ty(arena, interner, ty_uint(ast::TyU32)), u64: intern_ty(arena, interner, ty_uint(ast::TyU64)), f32: intern_ty(arena, interner, ty_float(ast::TyF32)), f64: intern_ty(arena, interner, ty_float(ast::TyF64)), } } } pub fn mk_ctxt<'tcx>(s: Session, arenas: &'tcx CtxtArenas<'tcx>, dm: DefMap, named_region_map: resolve_lifetime::NamedRegionMap, map: ast_map::Map<'tcx>, freevars: RefCell, capture_modes: RefCell, region_maps: middle::region::RegionMaps, lang_items: middle::lang_items::LanguageItems, stability: stability::Index) -> ctxt<'tcx> { let mut interner = FnvHashMap::new(); let common_types = CommonTypes::new(&arenas.type_, &mut interner); ctxt { arenas: arenas, interner: RefCell::new(interner), substs_interner: RefCell::new(FnvHashMap::new()), bare_fn_interner: RefCell::new(FnvHashMap::new()), region_interner: RefCell::new(FnvHashMap::new()), types: common_types, named_region_map: named_region_map, item_variance_map: RefCell::new(DefIdMap::new()), variance_computed: Cell::new(false), sess: s, def_map: dm, region_maps: region_maps, node_types: RefCell::new(FnvHashMap::new()), item_substs: RefCell::new(NodeMap::new()), trait_refs: RefCell::new(NodeMap::new()), trait_defs: RefCell::new(DefIdMap::new()), object_cast_map: RefCell::new(NodeMap::new()), map: map, intrinsic_defs: RefCell::new(DefIdMap::new()), freevars: freevars, tcache: RefCell::new(DefIdMap::new()), rcache: RefCell::new(FnvHashMap::new()), short_names_cache: RefCell::new(FnvHashMap::new()), tc_cache: RefCell::new(FnvHashMap::new()), ast_ty_to_ty_cache: RefCell::new(NodeMap::new()), enum_var_cache: RefCell::new(DefIdMap::new()), impl_or_trait_items: RefCell::new(DefIdMap::new()), trait_item_def_ids: RefCell::new(DefIdMap::new()), trait_items_cache: RefCell::new(DefIdMap::new()), impl_trait_cache: RefCell::new(DefIdMap::new()), ty_param_defs: RefCell::new(NodeMap::new()), adjustments: RefCell::new(NodeMap::new()), normalized_cache: RefCell::new(FnvHashMap::new()), lang_items: lang_items, provided_method_sources: RefCell::new(DefIdMap::new()), struct_fields: RefCell::new(DefIdMap::new()), destructor_for_type: RefCell::new(DefIdMap::new()), destructors: RefCell::new(DefIdSet::new()), trait_impls: RefCell::new(DefIdMap::new()), inherent_impls: RefCell::new(DefIdMap::new()), impl_items: RefCell::new(DefIdMap::new()), used_unsafe: RefCell::new(NodeSet::new()), used_mut_nodes: RefCell::new(NodeSet::new()), populated_external_types: RefCell::new(DefIdSet::new()), populated_external_traits: RefCell::new(DefIdSet::new()), upvar_borrow_map: RefCell::new(FnvHashMap::new()), extern_const_statics: RefCell::new(DefIdMap::new()), extern_const_variants: RefCell::new(DefIdMap::new()), method_map: RefCell::new(FnvHashMap::new()), dependency_formats: RefCell::new(FnvHashMap::new()), unboxed_closures: RefCell::new(DefIdMap::new()), node_lint_levels: RefCell::new(FnvHashMap::new()), transmute_restrictions: RefCell::new(Vec::new()), stability: RefCell::new(stability), capture_modes: capture_modes, associated_types: RefCell::new(DefIdMap::new()), selection_cache: traits::SelectionCache::new(), repr_hint_cache: RefCell::new(DefIdMap::new()), type_impls_copy_cache: RefCell::new(HashMap::new()), type_impls_sized_cache: RefCell::new(HashMap::new()), object_safety_cache: RefCell::new(DefIdMap::new()), } } // Type constructors impl<'tcx> ctxt<'tcx> { pub fn mk_substs(&self, substs: Substs<'tcx>) -> &'tcx Substs<'tcx> { if let Some(substs) = self.substs_interner.borrow().get(&substs) { return *substs; } let substs = self.arenas.substs.alloc(substs); self.substs_interner.borrow_mut().insert(substs, substs); substs } pub fn mk_bare_fn(&self, bare_fn: BareFnTy<'tcx>) -> &'tcx BareFnTy<'tcx> { if let Some(bare_fn) = self.bare_fn_interner.borrow().get(&bare_fn) { return *bare_fn; } let bare_fn = self.arenas.bare_fn.alloc(bare_fn); self.bare_fn_interner.borrow_mut().insert(bare_fn, bare_fn); bare_fn } pub fn mk_region(&self, region: Region) -> &'tcx Region { if let Some(region) = self.region_interner.borrow().get(®ion) { return *region; } let region = self.arenas.region.alloc(region); self.region_interner.borrow_mut().insert(region, region); region } pub fn unboxed_closure_kind(&self, def_id: ast::DefId) -> ty::UnboxedClosureKind { self.unboxed_closures.borrow()[def_id].kind } pub fn unboxed_closure_type(&self, def_id: ast::DefId, substs: &subst::Substs<'tcx>) -> ty::ClosureTy<'tcx> { self.unboxed_closures.borrow()[def_id].closure_type.subst(self, substs) } } // Interns a type/name combination, stores the resulting box in cx.interner, // and returns the box as cast to an unsafe ptr (see comments for Ty above). pub fn mk_t<'tcx>(cx: &ctxt<'tcx>, st: sty<'tcx>) -> Ty<'tcx> { let mut interner = cx.interner.borrow_mut(); intern_ty(&cx.arenas.type_, &mut *interner, st) } fn intern_ty<'tcx>(type_arena: &'tcx TypedArena>, interner: &mut FnvHashMap, Ty<'tcx>>, st: sty<'tcx>) -> Ty<'tcx> { match interner.get(&st) { Some(ty) => return *ty, _ => () } let flags = FlagComputation::for_sty(&st); let ty = type_arena.alloc(TyS { sty: st, flags: flags.flags, region_depth: flags.depth, }); debug!("Interned type: {} Pointer: {}", ty, ty as *const _); interner.insert(InternedTy { ty: ty }, ty); ty } struct FlagComputation { flags: TypeFlags, // maximum depth of any bound region that we have seen thus far depth: u32, } impl FlagComputation { fn new() -> FlagComputation { FlagComputation { flags: NO_TYPE_FLAGS, depth: 0 } } fn for_sty(st: &sty) -> FlagComputation { let mut result = FlagComputation::new(); result.add_sty(st); result } fn add_flags(&mut self, flags: TypeFlags) { self.flags = self.flags | flags; } fn add_depth(&mut self, depth: u32) { if depth > self.depth { self.depth = depth; } } /// Adds the flags/depth from a set of types that appear within the current type, but within a /// region binder. fn add_bound_computation(&mut self, computation: &FlagComputation) { self.add_flags(computation.flags); // The types that contributed to `computation` occured within // a region binder, so subtract one from the region depth // within when adding the depth to `self`. let depth = computation.depth; if depth > 0 { self.add_depth(depth - 1); } } fn add_sty(&mut self, st: &sty) { match st { &ty_bool | &ty_char | &ty_int(_) | &ty_float(_) | &ty_uint(_) | &ty_str => { } // You might think that we could just return ty_err for // any type containing ty_err as a component, and get // rid of the HAS_TY_ERR flag -- likewise for ty_bot (with // the exception of function types that return bot). // But doing so caused sporadic memory corruption, and // neither I (tjc) nor nmatsakis could figure out why, // so we're doing it this way. &ty_err => { self.add_flags(HAS_TY_ERR) } &ty_param(ref p) => { if p.space == subst::SelfSpace { self.add_flags(HAS_SELF); } else { self.add_flags(HAS_PARAMS); } } &ty_unboxed_closure(_, region, substs) => { self.add_region(*region); self.add_substs(substs); } &ty_infer(_) => { self.add_flags(HAS_TY_INFER) } &ty_enum(_, substs) | &ty_struct(_, substs) => { self.add_substs(substs); } &ty_projection(ref data) => { self.add_flags(HAS_PROJECTION); self.add_substs(data.trait_ref.substs); } &ty_trait(box TyTrait { ref principal, ref bounds }) => { let mut computation = FlagComputation::new(); computation.add_substs(principal.0.substs); self.add_bound_computation(&computation); self.add_bounds(bounds); } &ty_uniq(tt) | &ty_vec(tt, _) | &ty_open(tt) => { self.add_ty(tt) } &ty_ptr(ref m) => { self.add_ty(m.ty); } &ty_rptr(r, ref m) => { self.add_region(*r); self.add_ty(m.ty); } &ty_tup(ref ts) => { self.add_tys(ts[]); } &ty_bare_fn(_, ref f) => { self.add_fn_sig(&f.sig); } } } fn add_ty(&mut self, ty: Ty) { self.add_flags(ty.flags); self.add_depth(ty.region_depth); } fn add_tys(&mut self, tys: &[Ty]) { for &ty in tys.iter() { self.add_ty(ty); } } fn add_fn_sig(&mut self, fn_sig: &PolyFnSig) { let mut computation = FlagComputation::new(); computation.add_tys(fn_sig.0.inputs[]); if let ty::FnConverging(output) = fn_sig.0.output { computation.add_ty(output); } self.add_bound_computation(&computation); } fn add_region(&mut self, r: Region) { self.add_flags(HAS_REGIONS); match r { ty::ReInfer(_) => { self.add_flags(HAS_RE_INFER); } ty::ReLateBound(debruijn, _) => { self.add_flags(HAS_RE_LATE_BOUND); self.add_depth(debruijn.depth); } _ => { } } } fn add_substs(&mut self, substs: &Substs) { self.add_tys(substs.types.as_slice()); match substs.regions { subst::ErasedRegions => {} subst::NonerasedRegions(ref regions) => { for &r in regions.iter() { self.add_region(r); } } } } fn add_bounds(&mut self, bounds: &ExistentialBounds) { self.add_region(bounds.region_bound); } } pub fn mk_mach_int<'tcx>(tcx: &ctxt<'tcx>, tm: ast::IntTy) -> Ty<'tcx> { match tm { ast::TyI => tcx.types.int, ast::TyI8 => tcx.types.i8, ast::TyI16 => tcx.types.i16, ast::TyI32 => tcx.types.i32, ast::TyI64 => tcx.types.i64, } } pub fn mk_mach_uint<'tcx>(tcx: &ctxt<'tcx>, tm: ast::UintTy) -> Ty<'tcx> { match tm { ast::TyU => tcx.types.uint, ast::TyU8 => tcx.types.u8, ast::TyU16 => tcx.types.u16, ast::TyU32 => tcx.types.u32, ast::TyU64 => tcx.types.u64, } } pub fn mk_mach_float<'tcx>(tcx: &ctxt<'tcx>, tm: ast::FloatTy) -> Ty<'tcx> { match tm { ast::TyF32 => tcx.types.f32, ast::TyF64 => tcx.types.f64, } } pub fn mk_str<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> { mk_t(cx, ty_str) } pub fn mk_str_slice<'tcx>(cx: &ctxt<'tcx>, r: &'tcx Region, m: ast::Mutability) -> Ty<'tcx> { mk_rptr(cx, r, mt { ty: mk_t(cx, ty_str), mutbl: m }) } pub fn mk_enum<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> { // take a copy of substs so that we own the vectors inside mk_t(cx, ty_enum(did, substs)) } pub fn mk_uniq<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { mk_t(cx, ty_uniq(ty)) } pub fn mk_ptr<'tcx>(cx: &ctxt<'tcx>, tm: mt<'tcx>) -> Ty<'tcx> { mk_t(cx, ty_ptr(tm)) } pub fn mk_rptr<'tcx>(cx: &ctxt<'tcx>, r: &'tcx Region, tm: mt<'tcx>) -> Ty<'tcx> { mk_t(cx, ty_rptr(r, tm)) } pub fn mk_mut_rptr<'tcx>(cx: &ctxt<'tcx>, r: &'tcx Region, ty: Ty<'tcx>) -> Ty<'tcx> { mk_rptr(cx, r, mt {ty: ty, mutbl: ast::MutMutable}) } pub fn mk_imm_rptr<'tcx>(cx: &ctxt<'tcx>, r: &'tcx Region, ty: Ty<'tcx>) -> Ty<'tcx> { mk_rptr(cx, r, mt {ty: ty, mutbl: ast::MutImmutable}) } pub fn mk_mut_ptr<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { mk_ptr(cx, mt {ty: ty, mutbl: ast::MutMutable}) } pub fn mk_imm_ptr<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { mk_ptr(cx, mt {ty: ty, mutbl: ast::MutImmutable}) } pub fn mk_nil_ptr<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> { mk_ptr(cx, mt {ty: mk_nil(cx), mutbl: ast::MutImmutable}) } pub fn mk_vec<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, sz: Option) -> Ty<'tcx> { mk_t(cx, ty_vec(ty, sz)) } pub fn mk_slice<'tcx>(cx: &ctxt<'tcx>, r: &'tcx Region, tm: mt<'tcx>) -> Ty<'tcx> { mk_rptr(cx, r, mt { ty: mk_vec(cx, tm.ty, None), mutbl: tm.mutbl }) } pub fn mk_tup<'tcx>(cx: &ctxt<'tcx>, ts: Vec>) -> Ty<'tcx> { mk_t(cx, ty_tup(ts)) } pub fn mk_nil<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> { mk_tup(cx, Vec::new()) } pub fn mk_bare_fn<'tcx>(cx: &ctxt<'tcx>, opt_def_id: Option, fty: &'tcx BareFnTy<'tcx>) -> Ty<'tcx> { mk_t(cx, ty_bare_fn(opt_def_id, fty)) } pub fn mk_ctor_fn<'tcx>(cx: &ctxt<'tcx>, def_id: ast::DefId, input_tys: &[Ty<'tcx>], output: Ty<'tcx>) -> Ty<'tcx> { let input_args = input_tys.iter().map(|ty| *ty).collect(); mk_bare_fn(cx, Some(def_id), cx.mk_bare_fn(BareFnTy { unsafety: ast::Unsafety::Normal, abi: abi::Rust, sig: ty::Binder(FnSig { inputs: input_args, output: ty::FnConverging(output), variadic: false }) })) } pub fn mk_trait<'tcx>(cx: &ctxt<'tcx>, principal: ty::PolyTraitRef<'tcx>, bounds: ExistentialBounds<'tcx>) -> Ty<'tcx> { assert!(bound_list_is_sorted(bounds.projection_bounds.as_slice())); let inner = box TyTrait { principal: principal, bounds: bounds }; mk_t(cx, ty_trait(inner)) } fn bound_list_is_sorted(bounds: &[ty::PolyProjectionPredicate]) -> bool { bounds.len() == 0 || bounds[1..].iter().enumerate().all( |(index, bound)| bounds[index].sort_key() <= bound.sort_key()) } pub fn sort_bounds_list(bounds: &mut [ty::PolyProjectionPredicate]) { bounds.sort_by(|a, b| a.sort_key().cmp(&b.sort_key())) } pub fn mk_projection<'tcx>(cx: &ctxt<'tcx>, trait_ref: Rc>, item_name: ast::Name) -> Ty<'tcx> { // take a copy of substs so that we own the vectors inside let inner = ProjectionTy { trait_ref: trait_ref, item_name: item_name }; mk_t(cx, ty_projection(inner)) } pub fn mk_struct<'tcx>(cx: &ctxt<'tcx>, struct_id: ast::DefId, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> { // take a copy of substs so that we own the vectors inside mk_t(cx, ty_struct(struct_id, substs)) } pub fn mk_unboxed_closure<'tcx>(cx: &ctxt<'tcx>, closure_id: ast::DefId, region: &'tcx Region, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> { mk_t(cx, ty_unboxed_closure(closure_id, region, substs)) } pub fn mk_var<'tcx>(cx: &ctxt<'tcx>, v: TyVid) -> Ty<'tcx> { mk_infer(cx, TyVar(v)) } pub fn mk_int_var<'tcx>(cx: &ctxt<'tcx>, v: IntVid) -> Ty<'tcx> { mk_infer(cx, IntVar(v)) } pub fn mk_float_var<'tcx>(cx: &ctxt<'tcx>, v: FloatVid) -> Ty<'tcx> { mk_infer(cx, FloatVar(v)) } pub fn mk_infer<'tcx>(cx: &ctxt<'tcx>, it: InferTy) -> Ty<'tcx> { mk_t(cx, ty_infer(it)) } pub fn mk_param<'tcx>(cx: &ctxt<'tcx>, space: subst::ParamSpace, index: u32, name: ast::Name) -> Ty<'tcx> { mk_t(cx, ty_param(ParamTy { space: space, idx: index, name: name })) } pub fn mk_self_type<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> { mk_param(cx, subst::SelfSpace, 0, special_idents::type_self.name) } pub fn mk_param_from_def<'tcx>(cx: &ctxt<'tcx>, def: &TypeParameterDef) -> Ty<'tcx> { mk_param(cx, def.space, def.index, def.name) } pub fn mk_open<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { mk_t(cx, ty_open(ty)) } impl<'tcx> TyS<'tcx> { /// Iterator that walks `self` and any types reachable from /// `self`, in depth-first order. Note that just walks the types /// that appear in `self`, it does not descend into the fields of /// structs or variants. For example: /// /// ```notrust /// int => { int } /// Foo> => { Foo>, Bar, int } /// [int] => { [int], int } /// ``` pub fn walk(&'tcx self) -> TypeWalker<'tcx> { TypeWalker::new(self) } /// Iterator that walks types reachable from `self`, in /// depth-first order. Note that this is a shallow walk. For /// example: /// /// ```notrust /// int => { } /// Foo> => { Bar, int } /// [int] => { int } /// ``` pub fn walk_children(&'tcx self) -> TypeWalker<'tcx> { // Walks type reachable from `self` but not `self let mut walker = self.walk(); let r = walker.next(); assert_eq!(r, Some(self)); walker } } pub fn walk_ty<'tcx, F>(ty_root: Ty<'tcx>, mut f: F) where F: FnMut(Ty<'tcx>), { for ty in ty_root.walk() { f(ty); } } /// Walks `ty` and any types appearing within `ty`, invoking the /// callback `f` on each type. If the callback returns false, then the /// children of the current type are ignored. /// /// Note: prefer `ty.walk()` where possible. pub fn maybe_walk_ty<'tcx,F>(ty_root: Ty<'tcx>, mut f: F) where F : FnMut(Ty<'tcx>) -> bool { let mut walker = ty_root.walk(); while let Some(ty) = walker.next() { if !f(ty) { walker.skip_current_subtree(); } } } // Folds types from the bottom up. pub fn fold_ty<'tcx, F>(cx: &ctxt<'tcx>, t0: Ty<'tcx>, fldop: F) -> Ty<'tcx> where F: FnMut(Ty<'tcx>) -> Ty<'tcx>, { let mut f = ty_fold::BottomUpFolder {tcx: cx, fldop: fldop}; f.fold_ty(t0) } impl ParamTy { pub fn new(space: subst::ParamSpace, index: u32, name: ast::Name) -> ParamTy { ParamTy { space: space, idx: index, name: name } } pub fn for_self() -> ParamTy { ParamTy::new(subst::SelfSpace, 0, special_idents::type_self.name) } pub fn for_def(def: &TypeParameterDef) -> ParamTy { ParamTy::new(def.space, def.index, def.name) } pub fn to_ty<'tcx>(self, tcx: &ty::ctxt<'tcx>) -> Ty<'tcx> { ty::mk_param(tcx, self.space, self.idx, self.name) } pub fn is_self(&self) -> bool { self.space == subst::SelfSpace && self.idx == 0 } } impl<'tcx> ItemSubsts<'tcx> { pub fn empty() -> ItemSubsts<'tcx> { ItemSubsts { substs: Substs::empty() } } pub fn is_noop(&self) -> bool { self.substs.is_noop() } } impl<'tcx> ParamBounds<'tcx> { pub fn empty() -> ParamBounds<'tcx> { ParamBounds { builtin_bounds: empty_builtin_bounds(), trait_bounds: Vec::new(), region_bounds: Vec::new(), projection_bounds: Vec::new(), } } } // Type utilities pub fn type_is_nil(ty: Ty) -> bool { match ty.sty { ty_tup(ref tys) => tys.is_empty(), _ => false } } pub fn type_is_error(ty: Ty) -> bool { ty.flags.intersects(HAS_TY_ERR) } pub fn type_needs_subst(ty: Ty) -> bool { ty.flags.intersects(NEEDS_SUBST) } pub fn trait_ref_contains_error(tref: &ty::TraitRef) -> bool { tref.substs.types.any(|&ty| type_is_error(ty)) } pub fn type_is_ty_var(ty: Ty) -> bool { match ty.sty { ty_infer(TyVar(_)) => true, _ => false } } pub fn type_is_bool(ty: Ty) -> bool { ty.sty == ty_bool } pub fn type_is_self(ty: Ty) -> bool { match ty.sty { ty_param(ref p) => p.space == subst::SelfSpace, _ => false } } fn type_is_slice(ty: Ty) -> bool { match ty.sty { ty_ptr(mt) | ty_rptr(_, mt) => match mt.ty.sty { ty_vec(_, None) | ty_str => true, _ => false, }, _ => false } } pub fn type_is_vec(ty: Ty) -> bool { match ty.sty { ty_vec(..) => true, ty_ptr(mt{ty, ..}) | ty_rptr(_, mt{ty, ..}) | ty_uniq(ty) => match ty.sty { ty_vec(_, None) => true, _ => false }, _ => false } } pub fn type_is_structural(ty: Ty) -> bool { match ty.sty { ty_struct(..) | ty_tup(_) | ty_enum(..) | ty_vec(_, Some(_)) | ty_unboxed_closure(..) => true, _ => type_is_slice(ty) | type_is_trait(ty) } } pub fn type_is_simd(cx: &ctxt, ty: Ty) -> bool { match ty.sty { ty_struct(did, _) => lookup_simd(cx, did), _ => false } } pub fn sequence_element_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { match ty.sty { ty_vec(ty, _) => ty, ty_str => mk_mach_uint(cx, ast::TyU8), ty_open(ty) => sequence_element_type(cx, ty), _ => cx.sess.bug(format!("sequence_element_type called on non-sequence value: {}", ty_to_string(cx, ty))[]), } } pub fn simd_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { match ty.sty { ty_struct(did, substs) => { let fields = lookup_struct_fields(cx, did); lookup_field_type(cx, did, fields[0].id, substs) } _ => panic!("simd_type called on invalid type") } } pub fn simd_size(cx: &ctxt, ty: Ty) -> uint { match ty.sty { ty_struct(did, _) => { let fields = lookup_struct_fields(cx, did); fields.len() } _ => panic!("simd_size called on invalid type") } } pub fn type_is_region_ptr(ty: Ty) -> bool { match ty.sty { ty_rptr(..) => true, _ => false } } pub fn type_is_unsafe_ptr(ty: Ty) -> bool { match ty.sty { ty_ptr(_) => return true, _ => return false } } pub fn type_is_unique(ty: Ty) -> bool { match ty.sty { ty_uniq(_) => match ty.sty { ty_trait(..) => false, _ => true }, _ => false } } /* A scalar type is one that denotes an atomic datum, with no sub-components. (A ty_ptr is scalar because it represents a non-managed pointer, so its contents are abstract to rustc.) */ pub fn type_is_scalar(ty: Ty) -> bool { match ty.sty { ty_bool | ty_char | ty_int(_) | ty_float(_) | ty_uint(_) | ty_infer(IntVar(_)) | ty_infer(FloatVar(_)) | ty_bare_fn(..) | ty_ptr(_) => true, ty_tup(ref tys) if tys.is_empty() => true, _ => false } } /// Returns true if this type is a floating point type and false otherwise. pub fn type_is_floating_point(ty: Ty) -> bool { match ty.sty { ty_float(_) => true, _ => false, } } /// Type contents is how the type checker reasons about kinds. /// They track what kinds of things are found within a type. You can /// think of them as kind of an "anti-kind". They track the kinds of values /// and thinks that are contained in types. Having a larger contents for /// a type tends to rule that type *out* from various kinds. For example, /// a type that contains a reference is not sendable. /// /// The reason we compute type contents and not kinds is that it is /// easier for me (nmatsakis) to think about what is contained within /// a type than to think about what is *not* contained within a type. #[derive(Clone, Copy)] pub struct TypeContents { pub bits: u64 } macro_rules! def_type_content_sets { (mod $mname:ident { $($name:ident = $bits:expr),+ }) => { #[allow(non_snake_case)] mod $mname { use middle::ty::TypeContents; $( #[allow(non_upper_case_globals)] pub const $name: TypeContents = TypeContents { bits: $bits }; )+ } } } def_type_content_sets! { mod TC { None = 0b0000_0000__0000_0000__0000, // Things that are interior to the value (first nibble): InteriorUnsized = 0b0000_0000__0000_0000__0001, InteriorUnsafe = 0b0000_0000__0000_0000__0010, InteriorParam = 0b0000_0000__0000_0000__0100, // InteriorAll = 0b00000000__00000000__1111, // Things that are owned by the value (second and third nibbles): OwnsOwned = 0b0000_0000__0000_0001__0000, OwnsDtor = 0b0000_0000__0000_0010__0000, OwnsManaged /* see [1] below */ = 0b0000_0000__0000_0100__0000, OwnsAll = 0b0000_0000__1111_1111__0000, // Things that are reachable by the value in any way (fourth nibble): ReachesBorrowed = 0b0000_0010__0000_0000__0000, // ReachesManaged /* see [1] below */ = 0b0000_0100__0000_0000__0000, ReachesMutable = 0b0000_1000__0000_0000__0000, ReachesFfiUnsafe = 0b0010_0000__0000_0000__0000, ReachesAll = 0b0011_1111__0000_0000__0000, // Things that mean drop glue is necessary NeedsDrop = 0b0000_0000__0000_0111__0000, // Things that prevent values from being considered sized Nonsized = 0b0000_0000__0000_0000__0001, // Bits to set when a managed value is encountered // // [1] Do not set the bits TC::OwnsManaged or // TC::ReachesManaged directly, instead reference // TC::Managed to set them both at once. Managed = 0b0000_0100__0000_0100__0000, // All bits All = 0b1111_1111__1111_1111__1111 } } impl TypeContents { pub fn when(&self, cond: bool) -> TypeContents { if cond {*self} else {TC::None} } pub fn intersects(&self, tc: TypeContents) -> bool { (self.bits & tc.bits) != 0 } pub fn owns_managed(&self) -> bool { self.intersects(TC::OwnsManaged) } pub fn owns_owned(&self) -> bool { self.intersects(TC::OwnsOwned) } pub fn is_sized(&self, _: &ctxt) -> bool { !self.intersects(TC::Nonsized) } pub fn interior_param(&self) -> bool { self.intersects(TC::InteriorParam) } pub fn interior_unsafe(&self) -> bool { self.intersects(TC::InteriorUnsafe) } pub fn interior_unsized(&self) -> bool { self.intersects(TC::InteriorUnsized) } pub fn needs_drop(&self, _: &ctxt) -> bool { self.intersects(TC::NeedsDrop) } /// Includes only those bits that still apply when indirected through a `Box` pointer pub fn owned_pointer(&self) -> TypeContents { TC::OwnsOwned | ( *self & (TC::OwnsAll | TC::ReachesAll)) } /// Includes only those bits that still apply when indirected through a reference (`&`) pub fn reference(&self, bits: TypeContents) -> TypeContents { bits | ( *self & TC::ReachesAll) } /// Includes only those bits that still apply when indirected through a managed pointer (`@`) pub fn managed_pointer(&self) -> TypeContents { TC::Managed | ( *self & TC::ReachesAll) } /// Includes only those bits that still apply when indirected through an unsafe pointer (`*`) pub fn unsafe_pointer(&self) -> TypeContents { *self & TC::ReachesAll } pub fn union(v: &[T], mut f: F) -> TypeContents where F: FnMut(&T) -> TypeContents, { v.iter().fold(TC::None, |tc, ty| tc | f(ty)) } pub fn has_dtor(&self) -> bool { self.intersects(TC::OwnsDtor) } } impl ops::BitOr for TypeContents { type Output = TypeContents; fn bitor(self, other: TypeContents) -> TypeContents { TypeContents {bits: self.bits | other.bits} } } impl ops::BitAnd for TypeContents { type Output = TypeContents; fn bitand(self, other: TypeContents) -> TypeContents { TypeContents {bits: self.bits & other.bits} } } impl ops::Sub for TypeContents { type Output = TypeContents; fn sub(self, other: TypeContents) -> TypeContents { TypeContents {bits: self.bits & !other.bits} } } impl fmt::Show for TypeContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "TypeContents({:b})", self.bits) } } pub fn type_interior_is_unsafe<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> bool { type_contents(cx, ty).interior_unsafe() } pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { return memoized(&cx.tc_cache, ty, |ty| { tc_ty(cx, ty, &mut FnvHashMap::new()) }); fn tc_ty<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, cache: &mut FnvHashMap, TypeContents>) -> TypeContents { // Subtle: Note that we are *not* using cx.tc_cache here but rather a // private cache for this walk. This is needed in the case of cyclic // types like: // // struct List { next: Box>, ... } // // When computing the type contents of such a type, we wind up deeply // recursing as we go. So when we encounter the recursive reference // to List, we temporarily use TC::None as its contents. Later we'll // patch up the cache with the correct value, once we've computed it // (this is basically a co-inductive process, if that helps). So in // the end we'll compute TC::OwnsOwned, in this case. // // The problem is, as we are doing the computation, we will also // compute an *intermediate* contents for, e.g., Option of // TC::None. This is ok during the computation of List itself, but if // we stored this intermediate value into cx.tc_cache, then later // requests for the contents of Option would also yield TC::None // which is incorrect. This value was computed based on the crutch // value for the type contents of list. The correct value is // TC::OwnsOwned. This manifested as issue #4821. match cache.get(&ty) { Some(tc) => { return *tc; } None => {} } match cx.tc_cache.borrow().get(&ty) { // Must check both caches! Some(tc) => { return *tc; } None => {} } cache.insert(ty, TC::None); let result = match ty.sty { // uint and int are ffi-unsafe ty_uint(ast::TyU) | ty_int(ast::TyI) => { TC::ReachesFfiUnsafe } // Scalar and unique types are sendable, and durable ty_infer(ty::FreshIntTy(_)) | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) | ty_bare_fn(..) | ty::ty_char => { TC::None } ty_uniq(typ) => { TC::ReachesFfiUnsafe | match typ.sty { ty_str => TC::OwnsOwned, _ => tc_ty(cx, typ, cache).owned_pointer(), } } ty_trait(box TyTrait { ref bounds, .. }) => { object_contents(bounds) | TC::ReachesFfiUnsafe | TC::Nonsized } ty_ptr(ref mt) => { tc_ty(cx, mt.ty, cache).unsafe_pointer() } ty_rptr(r, ref mt) => { TC::ReachesFfiUnsafe | match mt.ty.sty { ty_str => borrowed_contents(*r, ast::MutImmutable), ty_vec(..) => tc_ty(cx, mt.ty, cache).reference(borrowed_contents(*r, mt.mutbl)), _ => tc_ty(cx, mt.ty, cache).reference(borrowed_contents(*r, mt.mutbl)), } } ty_vec(ty, Some(_)) => { tc_ty(cx, ty, cache) } ty_vec(ty, None) => { tc_ty(cx, ty, cache) | TC::Nonsized } ty_str => TC::Nonsized, ty_struct(did, substs) => { let flds = struct_fields(cx, did, substs); let mut res = TypeContents::union(flds[], |f| tc_mt(cx, f.mt, cache)); if !lookup_repr_hints(cx, did).contains(&attr::ReprExtern) { res = res | TC::ReachesFfiUnsafe; } if ty::has_dtor(cx, did) { res = res | TC::OwnsDtor; } apply_lang_items(cx, did, res) } ty_unboxed_closure(did, r, substs) => { // FIXME(#14449): `borrowed_contents` below assumes `&mut` // unboxed closure. let param_env = ty::empty_parameter_environment(cx); let upvars = unboxed_closure_upvars(¶m_env, did, substs).unwrap(); TypeContents::union(upvars.as_slice(), |f| tc_ty(cx, f.ty, cache)) | borrowed_contents(*r, MutMutable) } ty_tup(ref tys) => { TypeContents::union(tys[], |ty| tc_ty(cx, *ty, cache)) } ty_enum(did, substs) => { let variants = substd_enum_variants(cx, did, substs); let mut res = TypeContents::union(variants[], |variant| { TypeContents::union(variant.args[], |arg_ty| { tc_ty(cx, *arg_ty, cache) }) }); if ty::has_dtor(cx, did) { res = res | TC::OwnsDtor; } if variants.len() != 0 { let repr_hints = lookup_repr_hints(cx, did); if repr_hints.len() > 1 { // this is an error later on, but this type isn't safe res = res | TC::ReachesFfiUnsafe; } match repr_hints.get(0) { Some(h) => if !h.is_ffi_safe() { res = res | TC::ReachesFfiUnsafe; }, // ReprAny None => { res = res | TC::ReachesFfiUnsafe; // We allow ReprAny enums if they are eligible for // the nullable pointer optimization and the // contained type is an `extern fn` if variants.len() == 2 { let mut data_idx = 0; if variants[0].args.len() == 0 { data_idx = 1; } if variants[data_idx].args.len() == 1 { match variants[data_idx].args[0].sty { ty_bare_fn(..) => { res = res - TC::ReachesFfiUnsafe; } _ => { } } } } } } } apply_lang_items(cx, did, res) } ty_projection(..) | ty_param(_) => { TC::All } ty_open(ty) => { let result = tc_ty(cx, ty, cache); assert!(!result.is_sized(cx)); result.unsafe_pointer() | TC::Nonsized } ty_infer(_) | ty_err => { cx.sess.bug("asked to compute contents of error type"); } }; cache.insert(ty, result); result } fn tc_mt<'tcx>(cx: &ctxt<'tcx>, mt: mt<'tcx>, cache: &mut FnvHashMap, TypeContents>) -> TypeContents { let mc = TC::ReachesMutable.when(mt.mutbl == MutMutable); mc | tc_ty(cx, mt.ty, cache) } fn apply_lang_items(cx: &ctxt, did: ast::DefId, tc: TypeContents) -> TypeContents { if Some(did) == cx.lang_items.managed_bound() { tc | TC::Managed } else if Some(did) == cx.lang_items.unsafe_type() { tc | TC::InteriorUnsafe } else { tc } } /// Type contents due to containing a reference with the region `region` and borrow kind `bk` fn borrowed_contents(region: ty::Region, mutbl: ast::Mutability) -> TypeContents { let b = match mutbl { ast::MutMutable => TC::ReachesMutable, ast::MutImmutable => TC::None, }; b | (TC::ReachesBorrowed).when(region != ty::ReStatic) } fn object_contents(bounds: &ExistentialBounds) -> TypeContents { // These are the type contents of the (opaque) interior. We // make no assumptions (other than that it cannot have an // in-scope type parameter within, which makes no sense). let mut tc = TC::All - TC::InteriorParam; for bound in bounds.builtin_bounds.iter() { tc = tc - match bound { BoundSync | BoundSend | BoundCopy => TC::None, BoundSized => TC::Nonsized, }; } return tc; } } fn type_impls_bound<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>, cache: &RefCell,bool>>, ty: Ty<'tcx>, bound: ty::BuiltinBound, span: Span) -> bool { assert!(!ty::type_needs_infer(ty)); if !type_has_params(ty) && !type_has_self(ty) { match cache.borrow().get(&ty) { None => {} Some(&result) => { debug!("type_impls_bound({}, {}) = {} (cached)", ty.repr(param_env.tcx), bound, result); return result } } } let infcx = infer::new_infer_ctxt(param_env.tcx); let is_impld = traits::type_known_to_meet_builtin_bound(&infcx, param_env, ty, bound, span); debug!("type_impls_bound({}, {}) = {}", ty.repr(param_env.tcx), bound, is_impld); if !type_has_params(ty) && !type_has_self(ty) { let old_value = cache.borrow_mut().insert(ty, is_impld); assert!(old_value.is_none()); } is_impld } pub fn type_moves_by_default<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>, span: Span, ty: Ty<'tcx>) -> bool { let tcx = param_env.tcx; !type_impls_bound(param_env, &tcx.type_impls_copy_cache, ty, ty::BoundCopy, span) } pub fn type_is_sized<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>, span: Span, ty: Ty<'tcx>) -> bool { let tcx = param_env.tcx; type_impls_bound(param_env, &tcx.type_impls_sized_cache, ty, ty::BoundSized, span) } pub fn is_ffi_safe<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> bool { !type_contents(cx, ty).intersects(TC::ReachesFfiUnsafe) } // True if instantiating an instance of `r_ty` requires an instance of `r_ty`. pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool { fn type_requires<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec, r_ty: Ty<'tcx>, ty: Ty<'tcx>) -> bool { debug!("type_requires({}, {})?", ::util::ppaux::ty_to_string(cx, r_ty), ::util::ppaux::ty_to_string(cx, ty)); let r = r_ty == ty || subtypes_require(cx, seen, r_ty, ty); debug!("type_requires({}, {})? {}", ::util::ppaux::ty_to_string(cx, r_ty), ::util::ppaux::ty_to_string(cx, ty), r); return r; } fn subtypes_require<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec, r_ty: Ty<'tcx>, ty: Ty<'tcx>) -> bool { debug!("subtypes_require({}, {})?", ::util::ppaux::ty_to_string(cx, r_ty), ::util::ppaux::ty_to_string(cx, ty)); let r = match ty.sty { // fixed length vectors need special treatment compared to // normal vectors, since they don't necessarily have the // possibility to have length zero. ty_vec(_, Some(0)) => false, // don't need no contents ty_vec(ty, Some(_)) => type_requires(cx, seen, r_ty, ty), ty_bool | ty_char | ty_int(_) | ty_uint(_) | ty_float(_) | ty_str | ty_bare_fn(..) | ty_param(_) | ty_projection(_) | ty_vec(_, None) => { false } ty_uniq(typ) | ty_open(typ) => { type_requires(cx, seen, r_ty, typ) } ty_rptr(_, ref mt) => { type_requires(cx, seen, r_ty, mt.ty) } ty_ptr(..) => { false // unsafe ptrs can always be NULL } ty_trait(..) => { false } ty_struct(ref did, _) if seen.contains(did) => { false } ty_struct(did, substs) => { seen.push(did); let fields = struct_fields(cx, did, substs); let r = fields.iter().any(|f| type_requires(cx, seen, r_ty, f.mt.ty)); seen.pop().unwrap(); r } ty_err | ty_infer(_) | ty_unboxed_closure(..) => { // this check is run on type definitions, so we don't expect to see // inference by-products or unboxed closure types cx.sess.bug(format!("requires check invoked on inapplicable type: {}", ty)[]) } ty_tup(ref ts) => { ts.iter().any(|ty| type_requires(cx, seen, r_ty, *ty)) } ty_enum(ref did, _) if seen.contains(did) => { false } ty_enum(did, substs) => { seen.push(did); let vs = enum_variants(cx, did); let r = !vs.is_empty() && vs.iter().all(|variant| { variant.args.iter().any(|aty| { let sty = aty.subst(cx, substs); type_requires(cx, seen, r_ty, sty) }) }); seen.pop().unwrap(); r } }; debug!("subtypes_require({}, {})? {}", ::util::ppaux::ty_to_string(cx, r_ty), ::util::ppaux::ty_to_string(cx, ty), r); return r; } let mut seen = Vec::new(); !subtypes_require(cx, &mut seen, r_ty, r_ty) } /// Describes whether a type is representable. For types that are not /// representable, 'SelfRecursive' and 'ContainsRecursive' are used to /// distinguish between types that are recursive with themselves and types that /// contain a different recursive type. These cases can therefore be treated /// differently when reporting errors. /// /// The ordering of the cases is significant. They are sorted so that cmp::max /// will keep the "more erroneous" of two values. #[derive(Copy, PartialOrd, Ord, Eq, PartialEq, Show)] pub enum Representability { Representable, ContainsRecursive, SelfRecursive, } /// Check whether a type is representable. This means it cannot contain unboxed /// structural recursion. This check is needed for structs and enums. pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) -> Representability { // Iterate until something non-representable is found fn find_nonrepresentable<'tcx, It: Iterator>>(cx: &ctxt<'tcx>, sp: Span, seen: &mut Vec>, iter: It) -> Representability { iter.fold(Representable, |r, ty| cmp::max(r, is_type_structurally_recursive(cx, sp, seen, ty))) } fn are_inner_types_recursive<'tcx>(cx: &ctxt<'tcx>, sp: Span, seen: &mut Vec>, ty: Ty<'tcx>) -> Representability { match ty.sty { ty_tup(ref ts) => { find_nonrepresentable(cx, sp, seen, ts.iter().map(|ty| *ty)) } // Fixed-length vectors. // FIXME(#11924) Behavior undecided for zero-length vectors. ty_vec(ty, Some(_)) => { is_type_structurally_recursive(cx, sp, seen, ty) } ty_struct(did, substs) => { let fields = struct_fields(cx, did, substs); find_nonrepresentable(cx, sp, seen, fields.iter().map(|f| f.mt.ty)) } ty_enum(did, substs) => { let vs = enum_variants(cx, did); let iter = vs.iter() .flat_map(|variant| { variant.args.iter() }) .map(|aty| { aty.subst_spanned(cx, substs, Some(sp)) }); find_nonrepresentable(cx, sp, seen, iter) } ty_unboxed_closure(..) => { // this check is run on type definitions, so we don't expect to see // unboxed closure types cx.sess.bug(format!("requires check invoked on inapplicable type: {}", ty)[]) } _ => Representable, } } fn same_struct_or_enum_def_id(ty: Ty, did: DefId) -> bool { match ty.sty { ty_struct(ty_did, _) | ty_enum(ty_did, _) => { ty_did == did } _ => false } } fn same_type<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool { match (&a.sty, &b.sty) { (&ty_struct(did_a, ref substs_a), &ty_struct(did_b, ref substs_b)) | (&ty_enum(did_a, ref substs_a), &ty_enum(did_b, ref substs_b)) => { if did_a != did_b { return false; } let types_a = substs_a.types.get_slice(subst::TypeSpace); let types_b = substs_b.types.get_slice(subst::TypeSpace); let pairs = types_a.iter().zip(types_b.iter()); pairs.all(|(&a, &b)| same_type(a, b)) } _ => { a == b } } } // Does the type `ty` directly (without indirection through a pointer) // contain any types on stack `seen`? fn is_type_structurally_recursive<'tcx>(cx: &ctxt<'tcx>, sp: Span, seen: &mut Vec>, ty: Ty<'tcx>) -> Representability { debug!("is_type_structurally_recursive: {}", ::util::ppaux::ty_to_string(cx, ty)); match ty.sty { ty_struct(did, _) | ty_enum(did, _) => { { // Iterate through stack of previously seen types. let mut iter = seen.iter(); // The first item in `seen` is the type we are actually curious about. // We want to return SelfRecursive if this type contains itself. // It is important that we DON'T take generic parameters into account // for this check, so that Bar in this example counts as SelfRecursive: // // struct Foo; // struct Bar { x: Bar } match iter.next() { Some(&seen_type) => { if same_struct_or_enum_def_id(seen_type, did) { debug!("SelfRecursive: {} contains {}", ::util::ppaux::ty_to_string(cx, seen_type), ::util::ppaux::ty_to_string(cx, ty)); return SelfRecursive; } } None => {} } // We also need to know whether the first item contains other types that // are structurally recursive. If we don't catch this case, we will recurse // infinitely for some inputs. // // It is important that we DO take generic parameters into account here, // so that code like this is considered SelfRecursive, not ContainsRecursive: // // struct Foo { Option> } for &seen_type in iter { if same_type(ty, seen_type) { debug!("ContainsRecursive: {} contains {}", ::util::ppaux::ty_to_string(cx, seen_type), ::util::ppaux::ty_to_string(cx, ty)); return ContainsRecursive; } } } // For structs and enums, track all previously seen types by pushing them // onto the 'seen' stack. seen.push(ty); let out = are_inner_types_recursive(cx, sp, seen, ty); seen.pop(); out } _ => { // No need to push in other cases. are_inner_types_recursive(cx, sp, seen, ty) } } } debug!("is_type_representable: {}", ::util::ppaux::ty_to_string(cx, ty)); // To avoid a stack overflow when checking an enum variant or struct that // contains a different, structurally recursive type, maintain a stack // of seen types and check recursion for each of them (issues #3008, #3779). let mut seen: Vec = Vec::new(); let r = is_type_structurally_recursive(cx, sp, &mut seen, ty); debug!("is_type_representable: {} is {}", ::util::ppaux::ty_to_string(cx, ty), r); r } pub fn type_is_trait(ty: Ty) -> bool { type_trait_info(ty).is_some() } pub fn type_trait_info<'tcx>(ty: Ty<'tcx>) -> Option<&'tcx TyTrait<'tcx>> { match ty.sty { ty_uniq(ty) | ty_rptr(_, mt { ty, ..}) | ty_ptr(mt { ty, ..}) => match ty.sty { ty_trait(ref t) => Some(&**t), _ => None }, ty_trait(ref t) => Some(&**t), _ => None } } pub fn type_is_integral(ty: Ty) -> bool { match ty.sty { ty_infer(IntVar(_)) | ty_int(_) | ty_uint(_) => true, _ => false } } pub fn type_is_fresh(ty: Ty) -> bool { match ty.sty { ty_infer(FreshTy(_)) => true, ty_infer(FreshIntTy(_)) => true, _ => false } } pub fn type_is_uint(ty: Ty) -> bool { match ty.sty { ty_infer(IntVar(_)) | ty_uint(ast::TyU) => true, _ => false } } pub fn type_is_char(ty: Ty) -> bool { match ty.sty { ty_char => true, _ => false } } pub fn type_is_bare_fn(ty: Ty) -> bool { match ty.sty { ty_bare_fn(..) => true, _ => false } } pub fn type_is_bare_fn_item(ty: Ty) -> bool { match ty.sty { ty_bare_fn(Some(_), _) => true, _ => false } } pub fn type_is_fp(ty: Ty) -> bool { match ty.sty { ty_infer(FloatVar(_)) | ty_float(_) => true, _ => false } } pub fn type_is_numeric(ty: Ty) -> bool { return type_is_integral(ty) || type_is_fp(ty); } pub fn type_is_signed(ty: Ty) -> bool { match ty.sty { ty_int(_) => true, _ => false } } pub fn type_is_machine(ty: Ty) -> bool { match ty.sty { ty_int(ast::TyI) | ty_uint(ast::TyU) => false, ty_int(..) | ty_uint(..) | ty_float(..) => true, _ => false } } // Whether a type is enum like, that is an enum type with only nullary // constructors pub fn type_is_c_like_enum(cx: &ctxt, ty: Ty) -> bool { match ty.sty { ty_enum(did, _) => { let variants = enum_variants(cx, did); if variants.len() == 0 { false } else { variants.iter().all(|v| v.args.len() == 0) } } _ => false } } // Returns the type and mutability of *ty. // // The parameter `explicit` indicates if this is an *explicit* dereference. // Some types---notably unsafe ptrs---can only be dereferenced explicitly. pub fn deref<'tcx>(ty: Ty<'tcx>, explicit: bool) -> Option> { match ty.sty { ty_uniq(ty) => { Some(mt { ty: ty, mutbl: ast::MutImmutable, }) }, ty_rptr(_, mt) => Some(mt), ty_ptr(mt) if explicit => Some(mt), _ => None } } pub fn close_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { match ty.sty { ty_open(ty) => mk_rptr(cx, cx.mk_region(ReStatic), mt {ty: ty, mutbl:ast::MutImmutable}), _ => cx.sess.bug(format!("Trying to close a non-open type {}", ty_to_string(cx, ty))[]) } } pub fn type_content<'tcx>(ty: Ty<'tcx>) -> Ty<'tcx> { match ty.sty { ty_uniq(ty) => ty, ty_rptr(_, mt) |ty_ptr(mt) => mt.ty, _ => ty } } // Extract the unsized type in an open type (or just return ty if it is not open). pub fn unopen_type<'tcx>(ty: Ty<'tcx>) -> Ty<'tcx> { match ty.sty { ty_open(ty) => ty, _ => ty } } // Returns the type of ty[i] pub fn index<'tcx>(ty: Ty<'tcx>) -> Option> { match ty.sty { ty_vec(ty, _) => Some(ty), _ => None } } // Returns the type of elements contained within an 'array-like' type. // This is exactly the same as the above, except it supports strings, // which can't actually be indexed. pub fn array_element_ty<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Option> { match ty.sty { ty_vec(ty, _) => Some(ty), ty_str => Some(tcx.types.u8), _ => None } } /// Returns the type of element at index `i` in tuple or tuple-like type `t`. /// For an enum `t`, `variant` is None only if `t` is a univariant enum. pub fn positional_element_ty<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, i: uint, variant: Option) -> Option> { match (&ty.sty, variant) { (&ty_tup(ref v), None) => v.get(i).map(|&t| t), (&ty_struct(def_id, substs), None) => lookup_struct_fields(cx, def_id) .get(i) .map(|&t|lookup_item_type(cx, t.id).ty.subst(cx, substs)), (&ty_enum(def_id, substs), Some(variant_def_id)) => { let variant_info = enum_variant_with_id(cx, def_id, variant_def_id); variant_info.args.get(i).map(|t|t.subst(cx, substs)) } (&ty_enum(def_id, substs), None) => { assert!(enum_is_univariant(cx, def_id)); let enum_variants = enum_variants(cx, def_id); let variant_info = &(*enum_variants)[0]; variant_info.args.get(i).map(|t|t.subst(cx, substs)) } _ => None } } /// Returns the type of element at field `n` in struct or struct-like type `t`. /// For an enum `t`, `variant` must be some def id. pub fn named_element_ty<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, n: ast::Name, variant: Option) -> Option> { match (&ty.sty, variant) { (&ty_struct(def_id, substs), None) => { let r = lookup_struct_fields(cx, def_id); r.iter().find(|f| f.name == n) .map(|&f| lookup_field_type(cx, def_id, f.id, substs)) } (&ty_enum(def_id, substs), Some(variant_def_id)) => { let variant_info = enum_variant_with_id(cx, def_id, variant_def_id); variant_info.arg_names.as_ref() .expect("must have struct enum variant if accessing a named fields") .iter().zip(variant_info.args.iter()) .find(|&(ident, _)| ident.name == n) .map(|(_ident, arg_t)| arg_t.subst(cx, substs)) } _ => None } } pub fn node_id_to_trait_ref<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) -> Rc> { match cx.trait_refs.borrow().get(&id) { Some(ty) => ty.clone(), None => cx.sess.bug( format!("node_id_to_trait_ref: no trait ref for node `{}`", cx.map.node_to_string(id))[]) } } pub fn try_node_id_to_type<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) -> Option> { cx.node_types.borrow().get(&id).cloned() } pub fn node_id_to_type<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) -> Ty<'tcx> { match try_node_id_to_type(cx, id) { Some(ty) => ty, None => cx.sess.bug( format!("node_id_to_type: no type for node `{}`", cx.map.node_to_string(id))[]) } } pub fn node_id_to_type_opt<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) -> Option> { match cx.node_types.borrow().get(&id) { Some(&ty) => Some(ty), None => None } } pub fn node_id_item_substs<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) -> ItemSubsts<'tcx> { match cx.item_substs.borrow().get(&id) { None => ItemSubsts::empty(), Some(ts) => ts.clone(), } } pub fn fn_is_variadic(fty: Ty) -> bool { match fty.sty { ty_bare_fn(_, ref f) => f.sig.0.variadic, ref s => { panic!("fn_is_variadic() called on non-fn type: {}", s) } } } pub fn ty_fn_sig<'tcx>(fty: Ty<'tcx>) -> &'tcx PolyFnSig<'tcx> { match fty.sty { ty_bare_fn(_, ref f) => &f.sig, ref s => { panic!("ty_fn_sig() called on non-fn type: {}", s) } } } /// Returns the ABI of the given function. pub fn ty_fn_abi(fty: Ty) -> abi::Abi { match fty.sty { ty_bare_fn(_, ref f) => f.abi, _ => panic!("ty_fn_abi() called on non-fn type"), } } // Type accessors for substructures of types pub fn ty_fn_args<'tcx>(fty: Ty<'tcx>) -> &'tcx [Ty<'tcx>] { ty_fn_sig(fty).0.inputs.as_slice() } pub fn ty_closure_store(fty: Ty) -> TraitStore { match fty.sty { ty_unboxed_closure(..) => { // Close enough for the purposes of all the callers of this // function (which is soon to be deprecated anyhow). UniqTraitStore } ref s => { panic!("ty_closure_store() called on non-closure type: {}", s) } } } pub fn ty_fn_ret<'tcx>(fty: Ty<'tcx>) -> FnOutput<'tcx> { match fty.sty { ty_bare_fn(_, ref f) => f.sig.0.output, ref s => { panic!("ty_fn_ret() called on non-fn type: {}", s) } } } pub fn is_fn_ty(fty: Ty) -> bool { match fty.sty { ty_bare_fn(..) => true, _ => false } } pub fn ty_region(tcx: &ctxt, span: Span, ty: Ty) -> Region { match ty.sty { ty_rptr(r, _) => *r, ref s => { tcx.sess.span_bug( span, format!("ty_region() invoked on an inappropriate ty: {}", s)[]); } } } pub fn free_region_from_def(free_id: ast::NodeId, def: &RegionParameterDef) -> ty::Region { ty::ReFree(ty::FreeRegion { scope: region::CodeExtent::from_node_id(free_id), bound_region: ty::BrNamed(def.def_id, def.name) }) } // Returns the type of a pattern as a monotype. Like @expr_ty, this function // doesn't provide type parameter substitutions. pub fn pat_ty<'tcx>(cx: &ctxt<'tcx>, pat: &ast::Pat) -> Ty<'tcx> { return node_id_to_type(cx, pat.id); } // Returns the type of an expression as a monotype. // // NB (1): This is the PRE-ADJUSTMENT TYPE for the expression. That is, in // some cases, we insert `AutoAdjustment` annotations such as auto-deref or // auto-ref. The type returned by this function does not consider such // adjustments. See `expr_ty_adjusted()` instead. // // NB (2): This type doesn't provide type parameter substitutions; e.g. if you // ask for the type of "id" in "id(3)", it will return "fn(&int) -> int" // instead of "fn(ty) -> T with T = int". pub fn expr_ty<'tcx>(cx: &ctxt<'tcx>, expr: &ast::Expr) -> Ty<'tcx> { return node_id_to_type(cx, expr.id); } pub fn expr_ty_opt<'tcx>(cx: &ctxt<'tcx>, expr: &ast::Expr) -> Option> { return node_id_to_type_opt(cx, expr.id); } /// Returns the type of `expr`, considering any `AutoAdjustment` /// entry recorded for that expression. /// /// It would almost certainly be better to store the adjusted ty in with /// the `AutoAdjustment`, but I opted not to do this because it would /// require serializing and deserializing the type and, although that's not /// hard to do, I just hate that code so much I didn't want to touch it /// unless it was to fix it properly, which seemed a distraction from the /// task at hand! -nmatsakis pub fn expr_ty_adjusted<'tcx>(cx: &ctxt<'tcx>, expr: &ast::Expr) -> Ty<'tcx> { adjust_ty(cx, expr.span, expr.id, expr_ty(cx, expr), cx.adjustments.borrow().get(&expr.id), |method_call| cx.method_map.borrow().get(&method_call).map(|method| method.ty)) } pub fn expr_span(cx: &ctxt, id: NodeId) -> Span { match cx.map.find(id) { Some(ast_map::NodeExpr(e)) => { e.span } Some(f) => { cx.sess.bug(format!("Node id {} is not an expr: {}", id, f)[]); } None => { cx.sess.bug(format!("Node id {} is not present \ in the node map", id)[]); } } } pub fn local_var_name_str(cx: &ctxt, id: NodeId) -> InternedString { match cx.map.find(id) { Some(ast_map::NodeLocal(pat)) => { match pat.node { ast::PatIdent(_, ref path1, _) => { token::get_ident(path1.node) } _ => { cx.sess.bug( format!("Variable id {} maps to {}, not local", id, pat)[]); } } } r => { cx.sess.bug(format!("Variable id {} maps to {}, not local", id, r)[]); } } } /// See `expr_ty_adjusted` pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>, span: Span, expr_id: ast::NodeId, unadjusted_ty: Ty<'tcx>, adjustment: Option<&AutoAdjustment<'tcx>>, mut method_type: F) -> Ty<'tcx> where F: FnMut(MethodCall) -> Option>, { if let ty_err = unadjusted_ty.sty { return unadjusted_ty; } return match adjustment { Some(adjustment) => { match *adjustment { AdjustReifyFnPointer(_) => { match unadjusted_ty.sty { ty::ty_bare_fn(Some(_), b) => { ty::mk_bare_fn(cx, None, b) } ref b => { cx.sess.bug( format!("AdjustReifyFnPointer adjustment on non-fn-item: \ {}", b)[]); } } } AdjustDerefRef(ref adj) => { let mut adjusted_ty = unadjusted_ty; if !ty::type_is_error(adjusted_ty) { for i in range(0, adj.autoderefs) { let method_call = MethodCall::autoderef(expr_id, i); match method_type(method_call) { Some(method_ty) => { if let ty::FnConverging(result_type) = ty_fn_ret(method_ty) { adjusted_ty = result_type; } } None => {} } match deref(adjusted_ty, true) { Some(mt) => { adjusted_ty = mt.ty; } None => { cx.sess.span_bug( span, format!("the {}th autoderef failed: \ {}", i, ty_to_string(cx, adjusted_ty)) []); } } } } adjust_ty_for_autoref(cx, span, adjusted_ty, adj.autoref.as_ref()) } } } None => unadjusted_ty }; } pub fn adjust_ty_for_autoref<'tcx>(cx: &ctxt<'tcx>, span: Span, ty: Ty<'tcx>, autoref: Option<&AutoRef<'tcx>>) -> Ty<'tcx> { match autoref { None => ty, Some(&AutoPtr(r, m, ref a)) => { let adjusted_ty = match a { &Some(box ref a) => adjust_ty_for_autoref(cx, span, ty, Some(a)), &None => ty }; mk_rptr(cx, cx.mk_region(r), mt { ty: adjusted_ty, mutbl: m }) } Some(&AutoUnsafe(m, ref a)) => { let adjusted_ty = match a { &Some(box ref a) => adjust_ty_for_autoref(cx, span, ty, Some(a)), &None => ty }; mk_ptr(cx, mt {ty: adjusted_ty, mutbl: m}) } Some(&AutoUnsize(ref k)) => unsize_ty(cx, ty, k, span), Some(&AutoUnsizeUniq(ref k)) => ty::mk_uniq(cx, unsize_ty(cx, ty, k, span)), } } // Take a sized type and a sizing adjustment and produce an unsized version of // the type. pub fn unsize_ty<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, kind: &UnsizeKind<'tcx>, span: Span) -> Ty<'tcx> { match kind { &UnsizeLength(len) => match ty.sty { ty_vec(ty, Some(n)) => { assert!(len == n); mk_vec(cx, ty, None) } _ => cx.sess.span_bug(span, format!("UnsizeLength with bad sty: {}", ty_to_string(cx, ty))[]) }, &UnsizeStruct(box ref k, tp_index) => match ty.sty { ty_struct(did, substs) => { let ty_substs = substs.types.get_slice(subst::TypeSpace); let new_ty = unsize_ty(cx, ty_substs[tp_index], k, span); let mut unsized_substs = substs.clone(); unsized_substs.types.get_mut_slice(subst::TypeSpace)[tp_index] = new_ty; mk_struct(cx, did, cx.mk_substs(unsized_substs)) } _ => cx.sess.span_bug(span, format!("UnsizeStruct with bad sty: {}", ty_to_string(cx, ty))[]) }, &UnsizeVtable(TyTrait { ref principal, ref bounds }, _) => { mk_trait(cx, principal.clone(), bounds.clone()) } } } pub fn resolve_expr(tcx: &ctxt, expr: &ast::Expr) -> def::Def { match tcx.def_map.borrow().get(&expr.id) { Some(&def) => def, None => { tcx.sess.span_bug(expr.span, format!( "no def-map entry for expr {}", expr.id)[]); } } } pub fn expr_is_lval(tcx: &ctxt, e: &ast::Expr) -> bool { match expr_kind(tcx, e) { LvalueExpr => true, RvalueDpsExpr | RvalueDatumExpr | RvalueStmtExpr => false } } /// We categorize expressions into three kinds. The distinction between /// lvalue/rvalue is fundamental to the language. The distinction between the /// two kinds of rvalues is an artifact of trans which reflects how we will /// generate code for that kind of expression. See trans/expr.rs for more /// information. #[derive(Copy)] pub enum ExprKind { LvalueExpr, RvalueDpsExpr, RvalueDatumExpr, RvalueStmtExpr } pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind { if tcx.method_map.borrow().contains_key(&MethodCall::expr(expr.id)) { // Overloaded operations are generally calls, and hence they are // generated via DPS, but there are a few exceptions: return match expr.node { // `a += b` has a unit result. ast::ExprAssignOp(..) => RvalueStmtExpr, // the deref method invoked for `*a` always yields an `&T` ast::ExprUnary(ast::UnDeref, _) => LvalueExpr, // the index method invoked for `a[i]` always yields an `&T` ast::ExprIndex(..) => LvalueExpr, // `for` loops are statements ast::ExprForLoop(..) => RvalueStmtExpr, // in the general case, result could be any type, use DPS _ => RvalueDpsExpr }; } match expr.node { ast::ExprPath(..) => { match resolve_expr(tcx, expr) { def::DefVariant(tid, vid, _) => { let variant_info = enum_variant_with_id(tcx, tid, vid); if variant_info.args.len() > 0u { // N-ary variant. RvalueDatumExpr } else { // Nullary variant. RvalueDpsExpr } } def::DefStruct(_) => { match tcx.node_types.borrow().get(&expr.id) { Some(ty) => match ty.sty { ty_bare_fn(..) => RvalueDatumExpr, _ => RvalueDpsExpr }, // See ExprCast below for why types might be missing. None => RvalueDatumExpr } } // Special case: A unit like struct's constructor must be called without () at the // end (like `UnitStruct`) which means this is an ExprPath to a DefFn. But in case // of unit structs this is should not be interpreted as function pointer but as // call to the constructor. def::DefFn(_, true) => RvalueDpsExpr, // Fn pointers are just scalar values. def::DefFn(..) | def::DefStaticMethod(..) | def::DefMethod(..) => RvalueDatumExpr, // Note: there is actually a good case to be made that // DefArg's, particularly those of immediate type, ought to // considered rvalues. def::DefStatic(..) | def::DefUpvar(..) | def::DefLocal(..) => LvalueExpr, def::DefConst(..) => RvalueDatumExpr, def => { tcx.sess.span_bug( expr.span, format!("uncategorized def for expr {}: {}", expr.id, def)[]); } } } ast::ExprUnary(ast::UnDeref, _) | ast::ExprField(..) | ast::ExprTupField(..) | ast::ExprIndex(..) => { LvalueExpr } ast::ExprCall(..) | ast::ExprMethodCall(..) | ast::ExprStruct(..) | ast::ExprRange(..) | ast::ExprTup(..) | ast::ExprIf(..) | ast::ExprMatch(..) | ast::ExprClosure(..) | ast::ExprBlock(..) | ast::ExprRepeat(..) | ast::ExprVec(..) => { RvalueDpsExpr } ast::ExprIfLet(..) => { tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet"); } ast::ExprWhileLet(..) => { tcx.sess.span_bug(expr.span, "non-desugared ExprWhileLet"); } ast::ExprLit(ref lit) if lit_is_str(&**lit) => { RvalueDpsExpr } ast::ExprCast(..) => { match tcx.node_types.borrow().get(&expr.id) { Some(&ty) => { if type_is_trait(ty) { RvalueDpsExpr } else { RvalueDatumExpr } } None => { // Technically, it should not happen that the expr is not // present within the table. However, it DOES happen // during type check, because the final types from the // expressions are not yet recorded in the tcx. At that // time, though, we are only interested in knowing lvalue // vs rvalue. It would be better to base this decision on // the AST type in cast node---but (at the time of this // writing) it's not easy to distinguish casts to traits // from other casts based on the AST. This should be // easier in the future, when casts to traits // would like @Foo, Box, or &Foo. RvalueDatumExpr } } } ast::ExprBreak(..) | ast::ExprAgain(..) | ast::ExprRet(..) | ast::ExprWhile(..) | ast::ExprLoop(..) | ast::ExprAssign(..) | ast::ExprInlineAsm(..) | ast::ExprAssignOp(..) | ast::ExprForLoop(..) => { RvalueStmtExpr } ast::ExprLit(_) | // Note: LitStr is carved out above ast::ExprUnary(..) | ast::ExprBox(None, _) | ast::ExprAddrOf(..) | ast::ExprBinary(..) => { RvalueDatumExpr } ast::ExprBox(Some(ref place), _) => { // Special case `Box` for now: let definition = match tcx.def_map.borrow().get(&place.id) { Some(&def) => def, None => panic!("no def for place"), }; let def_id = definition.def_id(); if tcx.lang_items.exchange_heap() == Some(def_id) { RvalueDatumExpr } else { RvalueDpsExpr } } ast::ExprParen(ref e) => expr_kind(tcx, &**e), ast::ExprMac(..) => { tcx.sess.span_bug( expr.span, "macro expression remains after expansion"); } } } pub fn stmt_node_id(s: &ast::Stmt) -> ast::NodeId { match s.node { ast::StmtDecl(_, id) | StmtExpr(_, id) | StmtSemi(_, id) => { return id; } ast::StmtMac(..) => panic!("unexpanded macro in trans") } } pub fn field_idx_strict(tcx: &ctxt, name: ast::Name, fields: &[field]) -> uint { let mut i = 0u; for f in fields.iter() { if f.name == name { return i; } i += 1u; } tcx.sess.bug(format!( "no field named `{}` found in the list of fields `{}`", token::get_name(name), fields.iter() .map(|f| token::get_name(f.name).get().to_string()) .collect::>())[]); } pub fn impl_or_trait_item_idx(id: ast::Name, trait_items: &[ImplOrTraitItem]) -> Option { trait_items.iter().position(|m| m.name() == id) } pub fn ty_sort_string<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> String { match ty.sty { ty_bool | ty_char | ty_int(_) | ty_uint(_) | ty_float(_) | ty_str => { ::util::ppaux::ty_to_string(cx, ty) } ty_tup(ref tys) if tys.is_empty() => ::util::ppaux::ty_to_string(cx, ty), ty_enum(id, _) => format!("enum {}", item_path_str(cx, id)), ty_uniq(_) => "box".to_string(), ty_vec(_, Some(n)) => format!("array of {} elements", n), ty_vec(_, None) => "slice".to_string(), ty_ptr(_) => "*-ptr".to_string(), ty_rptr(_, _) => "&-ptr".to_string(), ty_bare_fn(Some(_), _) => format!("fn item"), ty_bare_fn(None, _) => "fn pointer".to_string(), ty_trait(ref inner) => { format!("trait {}", item_path_str(cx, inner.principal_def_id())) } ty_struct(id, _) => { format!("struct {}", item_path_str(cx, id)) } ty_unboxed_closure(..) => "closure".to_string(), ty_tup(_) => "tuple".to_string(), ty_infer(TyVar(_)) => "inferred type".to_string(), ty_infer(IntVar(_)) => "integral variable".to_string(), ty_infer(FloatVar(_)) => "floating-point variable".to_string(), ty_infer(FreshTy(_)) => "skolemized type".to_string(), ty_infer(FreshIntTy(_)) => "skolemized integral type".to_string(), ty_projection(_) => "associated type".to_string(), ty_param(ref p) => { if p.space == subst::SelfSpace { "Self".to_string() } else { "type parameter".to_string() } } ty_err => "type error".to_string(), ty_open(_) => "opened DST".to_string(), } } impl<'tcx> Repr<'tcx> for ty::type_err<'tcx> { fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String { ty::type_err_to_str(tcx, self) } } /// Explains the source of a type err in a short, human readable way. This is meant to be placed /// in parentheses after some larger message. You should also invoke `note_and_explain_type_err()` /// afterwards to present additional details, particularly when it comes to lifetime-related /// errors. pub fn type_err_to_str<'tcx>(cx: &ctxt<'tcx>, err: &type_err<'tcx>) -> String { fn tstore_to_closure(s: &TraitStore) -> String { match s { &UniqTraitStore => "proc".to_string(), &RegionTraitStore(..) => "closure".to_string() } } match *err { terr_cyclic_ty => "cyclic type of infinite size".to_string(), terr_mismatch => "types differ".to_string(), terr_unsafety_mismatch(values) => { format!("expected {} fn, found {} fn", values.expected.to_string(), values.found.to_string()) } terr_abi_mismatch(values) => { format!("expected {} fn, found {} fn", values.expected.to_string(), values.found.to_string()) } terr_onceness_mismatch(values) => { format!("expected {} fn, found {} fn", values.expected.to_string(), values.found.to_string()) } terr_sigil_mismatch(values) => { format!("expected {}, found {}", tstore_to_closure(&values.expected), tstore_to_closure(&values.found)) } terr_mutability => "values differ in mutability".to_string(), terr_box_mutability => { "boxed values differ in mutability".to_string() } terr_vec_mutability => "vectors differ in mutability".to_string(), terr_ptr_mutability => "pointers differ in mutability".to_string(), terr_ref_mutability => "references differ in mutability".to_string(), terr_ty_param_size(values) => { format!("expected a type with {} type params, \ found one with {} type params", values.expected, values.found) } terr_fixed_array_size(values) => { format!("expected an array with a fixed size of {} elements, \ found one with {} elements", values.expected, values.found) } terr_tuple_size(values) => { format!("expected a tuple with {} elements, \ found one with {} elements", values.expected, values.found) } terr_arg_count => { "incorrect number of function parameters".to_string() } terr_regions_does_not_outlive(..) => { "lifetime mismatch".to_string() } terr_regions_not_same(..) => { "lifetimes are not the same".to_string() } terr_regions_no_overlap(..) => { "lifetimes do not intersect".to_string() } terr_regions_insufficiently_polymorphic(br, _) => { format!("expected bound lifetime parameter {}, \ found concrete lifetime", bound_region_ptr_to_string(cx, br)) } terr_regions_overly_polymorphic(br, _) => { format!("expected concrete lifetime, \ found bound lifetime parameter {}", bound_region_ptr_to_string(cx, br)) } terr_trait_stores_differ(_, ref values) => { format!("trait storage differs: expected `{}`, found `{}`", trait_store_to_string(cx, (*values).expected), trait_store_to_string(cx, (*values).found)) } terr_sorts(values) => { // A naive approach to making sure that we're not reporting silly errors such as: // (expected closure, found closure). let expected_str = ty_sort_string(cx, values.expected); let found_str = ty_sort_string(cx, values.found); if expected_str == found_str { format!("expected {}, found a different {}", expected_str, found_str) } else { format!("expected {}, found {}", expected_str, found_str) } } terr_traits(values) => { format!("expected trait `{}`, found trait `{}`", item_path_str(cx, values.expected), item_path_str(cx, values.found)) } terr_builtin_bounds(values) => { if values.expected.is_empty() { format!("expected no bounds, found `{}`", values.found.user_string(cx)) } else if values.found.is_empty() { format!("expected bounds `{}`, found no bounds", values.expected.user_string(cx)) } else { format!("expected bounds `{}`, found bounds `{}`", values.expected.user_string(cx), values.found.user_string(cx)) } } terr_integer_as_char => { "expected an integral type, found `char`".to_string() } terr_int_mismatch(ref values) => { format!("expected `{}`, found `{}`", values.expected.to_string(), values.found.to_string()) } terr_float_mismatch(ref values) => { format!("expected `{}`, found `{}`", values.expected.to_string(), values.found.to_string()) } terr_variadic_mismatch(ref values) => { format!("expected {} fn, found {} function", if values.expected { "variadic" } else { "non-variadic" }, if values.found { "variadic" } else { "non-variadic" }) } terr_convergence_mismatch(ref values) => { format!("expected {} fn, found {} function", if values.expected { "converging" } else { "diverging" }, if values.found { "converging" } else { "diverging" }) } terr_projection_name_mismatched(ref values) => { format!("expected {}, found {}", token::get_name(values.expected), token::get_name(values.found)) } terr_projection_bounds_length(ref values) => { format!("expected {} associated type bindings, found {}", values.expected, values.found) } } } pub fn note_and_explain_type_err(cx: &ctxt, err: &type_err) { match *err { terr_regions_does_not_outlive(subregion, superregion) => { note_and_explain_region(cx, "", subregion, "..."); note_and_explain_region(cx, "...does not necessarily outlive ", superregion, ""); } terr_regions_not_same(region1, region2) => { note_and_explain_region(cx, "", region1, "..."); note_and_explain_region(cx, "...is not the same lifetime as ", region2, ""); } terr_regions_no_overlap(region1, region2) => { note_and_explain_region(cx, "", region1, "..."); note_and_explain_region(cx, "...does not overlap ", region2, ""); } terr_regions_insufficiently_polymorphic(_, conc_region) => { note_and_explain_region(cx, "concrete lifetime that was found is ", conc_region, ""); } terr_regions_overly_polymorphic(_, ty::ReInfer(ty::ReVar(_))) => { // don't bother to print out the message below for // inference variables, it's not very illuminating. } terr_regions_overly_polymorphic(_, conc_region) => { note_and_explain_region(cx, "expected concrete lifetime is ", conc_region, ""); } _ => {} } } pub fn provided_source(cx: &ctxt, id: ast::DefId) -> Option { cx.provided_method_sources.borrow().get(&id).map(|x| *x) } pub fn provided_trait_methods<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) -> Vec>> { if is_local(id) { match cx.map.find(id.node) { Some(ast_map::NodeItem(item)) => { match item.node { ItemTrait(_, _, _, ref ms) => { let (_, p) = ast_util::split_trait_methods(ms[]); p.iter() .map(|m| { match impl_or_trait_item( cx, ast_util::local_def(m.id)) { MethodTraitItem(m) => m, TypeTraitItem(_) => { cx.sess.bug("provided_trait_methods(): \ split_trait_methods() put \ associated types in the \ provided method bucket?!") } } }).collect() } _ => { cx.sess.bug(format!("provided_trait_methods: `{}` is \ not a trait", id)[]) } } } _ => { cx.sess.bug(format!("provided_trait_methods: `{}` is not a \ trait", id)[]) } } } else { csearch::get_provided_trait_methods(cx, id) } } /// Helper for looking things up in the various maps that are populated during /// typeck::collect (e.g., `cx.impl_or_trait_items`, `cx.tcache`, etc). All of /// these share the pattern that if the id is local, it should have been loaded /// into the map by the `typeck::collect` phase. If the def-id is external, /// then we have to go consult the crate loading code (and cache the result for /// the future). fn lookup_locally_or_in_crate_store(descr: &str, def_id: ast::DefId, map: &mut DefIdMap, load_external: F) -> V where V: Clone, F: FnOnce() -> V, { match map.get(&def_id).cloned() { Some(v) => { return v; } None => { } } if def_id.krate == ast::LOCAL_CRATE { panic!("No def'n found for {} in tcx.{}", def_id, descr); } let v = load_external(); map.insert(def_id, v.clone()); v } pub fn trait_item<'tcx>(cx: &ctxt<'tcx>, trait_did: ast::DefId, idx: uint) -> ImplOrTraitItem<'tcx> { let method_def_id = (*ty::trait_item_def_ids(cx, trait_did))[idx].def_id(); impl_or_trait_item(cx, method_def_id) } pub fn trait_items<'tcx>(cx: &ctxt<'tcx>, trait_did: ast::DefId) -> Rc>> { let mut trait_items = cx.trait_items_cache.borrow_mut(); match trait_items.get(&trait_did).cloned() { Some(trait_items) => trait_items, None => { let def_ids = ty::trait_item_def_ids(cx, trait_did); let items: Rc> = Rc::new(def_ids.iter() .map(|d| impl_or_trait_item(cx, d.def_id())) .collect()); trait_items.insert(trait_did, items.clone()); items } } } pub fn impl_or_trait_item<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) -> ImplOrTraitItem<'tcx> { lookup_locally_or_in_crate_store("impl_or_trait_items", id, &mut *cx.impl_or_trait_items .borrow_mut(), || { csearch::get_impl_or_trait_item(cx, id) }) } /// Returns true if the given ID refers to an associated type and false if it /// refers to anything else. pub fn is_associated_type(cx: &ctxt, id: ast::DefId) -> bool { memoized(&cx.associated_types, id, |id: ast::DefId| { if id.krate == ast::LOCAL_CRATE { match cx.impl_or_trait_items.borrow().get(&id) { Some(ref item) => { match **item { TypeTraitItem(_) => true, MethodTraitItem(_) => false, } } None => false, } } else { csearch::is_associated_type(&cx.sess.cstore, id) } }) } /// Returns the parameter index that the given associated type corresponds to. pub fn associated_type_parameter_index(cx: &ctxt, trait_def: &TraitDef, associated_type_id: ast::DefId) -> uint { for type_parameter_def in trait_def.generics.types.iter() { if type_parameter_def.def_id == associated_type_id { return type_parameter_def.index as uint } } cx.sess.bug("couldn't find associated type parameter index") } #[derive(Copy, PartialEq, Eq)] pub struct AssociatedTypeInfo { pub def_id: ast::DefId, pub index: uint, pub name: ast::Name, } impl PartialOrd for AssociatedTypeInfo { fn partial_cmp(&self, other: &AssociatedTypeInfo) -> Option { Some(self.index.cmp(&other.index)) } } impl Ord for AssociatedTypeInfo { fn cmp(&self, other: &AssociatedTypeInfo) -> Ordering { self.index.cmp(&other.index) } } pub fn trait_item_def_ids(cx: &ctxt, id: ast::DefId) -> Rc> { lookup_locally_or_in_crate_store("trait_item_def_ids", id, &mut *cx.trait_item_def_ids.borrow_mut(), || { Rc::new(csearch::get_trait_item_def_ids(&cx.sess.cstore, id)) }) } pub fn impl_trait_ref<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) -> Option>> { memoized(&cx.impl_trait_cache, id, |id: ast::DefId| { if id.krate == ast::LOCAL_CRATE { debug!("(impl_trait_ref) searching for trait impl {}", id); match cx.map.find(id.node) { Some(ast_map::NodeItem(item)) => { match item.node { ast::ItemImpl(_, _, _, ref opt_trait, _, _) => { match opt_trait { &Some(ref t) => { let trait_ref = ty::node_id_to_trait_ref(cx, t.ref_id); Some(trait_ref) } &None => None } } _ => None } } _ => None } } else { csearch::get_impl_trait(cx, id) } }) } pub fn trait_ref_to_def_id(tcx: &ctxt, tr: &ast::TraitRef) -> ast::DefId { let def = *tcx.def_map.borrow() .get(&tr.ref_id) .expect("no def-map entry for trait"); def.def_id() } pub fn try_add_builtin_trait( tcx: &ctxt, trait_def_id: ast::DefId, builtin_bounds: &mut EnumSet) -> bool { //! Checks whether `trait_ref` refers to one of the builtin //! traits, like `Send`, and adds the corresponding //! bound to the set `builtin_bounds` if so. Returns true if `trait_ref` //! is a builtin trait. match tcx.lang_items.to_builtin_kind(trait_def_id) { Some(bound) => { builtin_bounds.insert(bound); true } None => false } } pub fn ty_to_def_id(ty: Ty) -> Option { match ty.sty { ty_trait(ref tt) => Some(tt.principal_def_id()), ty_struct(id, _) | ty_enum(id, _) | ty_unboxed_closure(id, _, _) => Some(id), _ => None } } // Enum information #[derive(Clone)] pub struct VariantInfo<'tcx> { pub args: Vec>, pub arg_names: Option>, pub ctor_ty: Option>, pub name: ast::Name, pub id: ast::DefId, pub disr_val: Disr, pub vis: Visibility } impl<'tcx> VariantInfo<'tcx> { /// Creates a new VariantInfo from the corresponding ast representation. /// /// Does not do any caching of the value in the type context. pub fn from_ast_variant(cx: &ctxt<'tcx>, ast_variant: &ast::Variant, discriminant: Disr) -> VariantInfo<'tcx> { let ctor_ty = node_id_to_type(cx, ast_variant.node.id); match ast_variant.node.kind { ast::TupleVariantKind(ref args) => { let arg_tys = if args.len() > 0 { ty_fn_args(ctor_ty).iter().map(|a| *a).collect() } else { Vec::new() }; return VariantInfo { args: arg_tys, arg_names: None, ctor_ty: Some(ctor_ty), name: ast_variant.node.name.name, id: ast_util::local_def(ast_variant.node.id), disr_val: discriminant, vis: ast_variant.node.vis }; }, ast::StructVariantKind(ref struct_def) => { let fields: &[StructField] = struct_def.fields[]; assert!(fields.len() > 0); let arg_tys = struct_def.fields.iter() .map(|field| node_id_to_type(cx, field.node.id)).collect(); let arg_names = fields.iter().map(|field| { match field.node.kind { NamedField(ident, _) => ident, UnnamedField(..) => cx.sess.bug( "enum_variants: all fields in struct must have a name") } }).collect(); return VariantInfo { args: arg_tys, arg_names: Some(arg_names), ctor_ty: None, name: ast_variant.node.name.name, id: ast_util::local_def(ast_variant.node.id), disr_val: discriminant, vis: ast_variant.node.vis }; } } } } pub fn substd_enum_variants<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId, substs: &Substs<'tcx>) -> Vec>> { enum_variants(cx, id).iter().map(|variant_info| { let substd_args = variant_info.args.iter() .map(|aty| aty.subst(cx, substs)).collect::>(); let substd_ctor_ty = variant_info.ctor_ty.subst(cx, substs); Rc::new(VariantInfo { args: substd_args, ctor_ty: substd_ctor_ty, ..(**variant_info).clone() }) }).collect() } pub fn item_path_str(cx: &ctxt, id: ast::DefId) -> String { with_path(cx, id, |path| ast_map::path_to_string(path)).to_string() } #[derive(Copy)] pub enum DtorKind { NoDtor, TraitDtor(DefId, bool) } impl DtorKind { pub fn is_present(&self) -> bool { match *self { TraitDtor(..) => true, _ => false } } pub fn has_drop_flag(&self) -> bool { match self { &NoDtor => false, &TraitDtor(_, flag) => flag } } } /* If struct_id names a struct with a dtor, return Some(the dtor's id). Otherwise return none. */ pub fn ty_dtor(cx: &ctxt, struct_id: DefId) -> DtorKind { match cx.destructor_for_type.borrow().get(&struct_id) { Some(&method_def_id) => { let flag = !has_attr(cx, struct_id, "unsafe_no_drop_flag"); TraitDtor(method_def_id, flag) } None => NoDtor, } } pub fn has_dtor(cx: &ctxt, struct_id: DefId) -> bool { cx.destructor_for_type.borrow().contains_key(&struct_id) } pub fn with_path(cx: &ctxt, id: ast::DefId, f: F) -> T where F: FnOnce(ast_map::PathElems) -> T, { if id.krate == ast::LOCAL_CRATE { cx.map.with_path(id.node, f) } else { f(ast_map::Values(csearch::get_item_path(cx, id).iter()).chain(None)) } } pub fn enum_is_univariant(cx: &ctxt, id: ast::DefId) -> bool { enum_variants(cx, id).len() == 1 } pub fn type_is_empty(cx: &ctxt, ty: Ty) -> bool { match ty.sty { ty_enum(did, _) => (*enum_variants(cx, did)).is_empty(), _ => false } } pub fn enum_variants<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) -> Rc>>> { memoized(&cx.enum_var_cache, id, |id: ast::DefId| { if ast::LOCAL_CRATE != id.krate { Rc::new(csearch::get_enum_variants(cx, id)) } else { /* Although both this code and check_enum_variants in typeck/check call eval_const_expr, it should never get called twice for the same expr, since check_enum_variants also updates the enum_var_cache */ match cx.map.get(id.node) { ast_map::NodeItem(ref item) => { match item.node { ast::ItemEnum(ref enum_definition, _) => { let mut last_discriminant: Option = None; Rc::new(enum_definition.variants.iter().map(|variant| { let mut discriminant = match last_discriminant { Some(val) => val + 1, None => INITIAL_DISCRIMINANT_VALUE }; match variant.node.disr_expr { Some(ref e) => match const_eval::eval_const_expr_partial(cx, &**e) { Ok(const_eval::const_int(val)) => { discriminant = val as Disr } Ok(const_eval::const_uint(val)) => { discriminant = val as Disr } Ok(_) => { cx.sess .span_err(e.span, "expected signed integer constant"); } Err(ref err) => { cx.sess .span_err(e.span, format!("expected constant: {}", *err)[]); } }, None => {} }; last_discriminant = Some(discriminant); Rc::new(VariantInfo::from_ast_variant(cx, &**variant, discriminant)) }).collect()) } _ => { cx.sess.bug("enum_variants: id not bound to an enum") } } } _ => cx.sess.bug("enum_variants: id not bound to an enum") } } }) } // Returns information about the enum variant with the given ID: pub fn enum_variant_with_id<'tcx>(cx: &ctxt<'tcx>, enum_id: ast::DefId, variant_id: ast::DefId) -> Rc> { enum_variants(cx, enum_id).iter() .find(|variant| variant.id == variant_id) .expect("enum_variant_with_id(): no variant exists with that ID") .clone() } // If the given item is in an external crate, looks up its type and adds it to // the type cache. Returns the type parameters and type. pub fn lookup_item_type<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId) -> TypeScheme<'tcx> { lookup_locally_or_in_crate_store( "tcache", did, &mut *cx.tcache.borrow_mut(), || csearch::get_type(cx, did)) } /// Given the did of a trait, returns its canonical trait ref. pub fn lookup_trait_def<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId) -> Rc> { memoized(&cx.trait_defs, did, |did: DefId| { assert!(did.krate != ast::LOCAL_CRATE); Rc::new(csearch::get_trait_def(cx, did)) }) } /// Given a reference to a trait, returns the "superbounds" declared /// on the trait, with appropriate substitutions applied. Basically, /// this applies a filter to the where clauses on the trait, returning /// those that have the form: /// /// Self : SuperTrait<...> /// Self : 'region pub fn predicates_for_trait_ref<'tcx>(tcx: &ctxt<'tcx>, trait_ref: &PolyTraitRef<'tcx>) -> Vec> { let trait_def = lookup_trait_def(tcx, trait_ref.def_id()); debug!("bounds_for_trait_ref(trait_def={}, trait_ref={})", trait_def.repr(tcx), trait_ref.repr(tcx)); // The interaction between HRTB and supertraits is not entirely // obvious. Let me walk you (and myself) through an example. // // Let's start with an easy case. Consider two traits: // // trait Foo<'a> : Bar<'a,'a> { } // trait Bar<'b,'c> { } // // Now, if we have a trait reference `for<'x> T : Foo<'x>`, then // we can deduce that `for<'x> T : Bar<'x,'x>`. Basically, if we // knew that `Foo<'x>` (for any 'x) then we also know that // `Bar<'x,'x>` (for any 'x). This more-or-less falls out from // normal substitution. // // In terms of why this is sound, the idea is that whenever there // is an impl of `T:Foo<'a>`, it must show that `T:Bar<'a,'a>` // holds. So if there is an impl of `T:Foo<'a>` that applies to // all `'a`, then we must know that `T:Bar<'a,'a>` holds for all // `'a`. // // Another example to be careful of is this: // // trait Foo1<'a> : for<'b> Bar1<'a,'b> { } // trait Bar1<'b,'c> { } // // Here, if we have `for<'x> T : Foo1<'x>`, then what do we know? // The answer is that we know `for<'x,'b> T : Bar1<'x,'b>`. The // reason is similar to the previous example: any impl of // `T:Foo1<'x>` must show that `for<'b> T : Bar1<'x, 'b>`. So // basically we would want to collapse the bound lifetimes from // the input (`trait_ref`) and the supertraits. // // To achieve this in practice is fairly straightforward. Let's // consider the more complicated scenario: // // - We start out with `for<'x> T : Foo1<'x>`. In this case, `'x` // has a De Bruijn index of 1. We want to produce `for<'x,'b> T : Bar1<'x,'b>`, // where both `'x` and `'b` would have a DB index of 1. // The substitution from the input trait-ref is therefore going to be // `'a => 'x` (where `'x` has a DB index of 1). // - The super-trait-ref is `for<'b> Bar1<'a,'b>`, where `'a` is an // early-bound parameter and `'b' is a late-bound parameter with a // DB index of 1. // - If we replace `'a` with `'x` from the input, it too will have // a DB index of 1, and thus we'll have `for<'x,'b> Bar1<'x,'b>` // just as we wanted. // // There is only one catch. If we just apply the substitution `'a // => 'x` to `for<'b> Bar1<'a,'b>`, the substitution code will // adjust the DB index because we substituting into a binder (it // tries to be so smart...) resulting in `for<'x> for<'b> // Bar1<'x,'b>` (we have no syntax for this, so use your // imagination). Basically the 'x will have DB index of 2 and 'b // will have DB index of 1. Not quite what we want. So we apply // the substitution to the *contents* of the trait reference, // rather than the trait reference itself (put another way, the // substitution code expects equal binding levels in the values // from the substitution and the value being substituted into, and // this trick achieves that). // Carefully avoid the binder introduced by each trait-ref by // substituting over the substs, not the trait-refs themselves, // thus achieving the "collapse" described in the big comment // above. let trait_bounds: Vec<_> = trait_def.bounds.trait_bounds .iter() .map(|poly_trait_ref| ty::Binder(poly_trait_ref.0.subst(tcx, trait_ref.substs()))) .collect(); let projection_bounds: Vec<_> = trait_def.bounds.projection_bounds .iter() .map(|poly_proj| ty::Binder(poly_proj.0.subst(tcx, trait_ref.substs()))) .collect(); debug!("bounds_for_trait_ref: trait_bounds={} projection_bounds={}", trait_bounds.repr(tcx), projection_bounds.repr(tcx)); // The region bounds and builtin bounds do not currently introduce // binders so we can just substitute in a straightforward way here. let region_bounds = trait_def.bounds.region_bounds.subst(tcx, trait_ref.substs()); let builtin_bounds = trait_def.bounds.builtin_bounds.subst(tcx, trait_ref.substs()); let bounds = ty::ParamBounds { trait_bounds: trait_bounds, region_bounds: region_bounds, builtin_bounds: builtin_bounds, projection_bounds: projection_bounds, }; predicates(tcx, trait_ref.self_ty(), &bounds) } pub fn predicates<'tcx>( tcx: &ctxt<'tcx>, param_ty: Ty<'tcx>, bounds: &ParamBounds<'tcx>) -> Vec> { let mut vec = Vec::new(); for builtin_bound in bounds.builtin_bounds.iter() { match traits::trait_ref_for_builtin_bound(tcx, builtin_bound, param_ty) { Ok(trait_ref) => { vec.push(trait_ref.as_predicate()); } Err(ErrorReported) => { } } } for ®ion_bound in bounds.region_bounds.iter() { // account for the binder being introduced below; no need to shift `param_ty` // because, at present at least, it can only refer to early-bound regions let region_bound = ty_fold::shift_region(region_bound, 1); vec.push(ty::Binder(ty::OutlivesPredicate(param_ty, region_bound)).as_predicate()); } for bound_trait_ref in bounds.trait_bounds.iter() { vec.push(bound_trait_ref.as_predicate()); } for projection in bounds.projection_bounds.iter() { vec.push(projection.as_predicate()); } vec } /// Iterate over attributes of a definition. // (This should really be an iterator, but that would require csearch and // decoder to use iterators instead of higher-order functions.) pub fn each_attr(tcx: &ctxt, did: DefId, mut f: F) -> bool where F: FnMut(&ast::Attribute) -> bool, { if is_local(did) { let item = tcx.map.expect_item(did.node); item.attrs.iter().all(|attr| f(attr)) } else { info!("getting foreign attrs"); let mut cont = true; csearch::get_item_attrs(&tcx.sess.cstore, did, |attrs| { if cont { cont = attrs.iter().all(|attr| f(attr)); } }); info!("done"); cont } } /// Determine whether an item is annotated with an attribute pub fn has_attr(tcx: &ctxt, did: DefId, attr: &str) -> bool { let mut found = false; each_attr(tcx, did, |item| { if item.check_name(attr) { found = true; false } else { true } }); found } /// Determine whether an item is annotated with `#[repr(packed)]` pub fn lookup_packed(tcx: &ctxt, did: DefId) -> bool { lookup_repr_hints(tcx, did).contains(&attr::ReprPacked) } /// Determine whether an item is annotated with `#[simd]` pub fn lookup_simd(tcx: &ctxt, did: DefId) -> bool { has_attr(tcx, did, "simd") } /// Obtain the representation annotation for a struct definition. pub fn lookup_repr_hints(tcx: &ctxt, did: DefId) -> Rc> { memoized(&tcx.repr_hint_cache, did, |did: DefId| { Rc::new(if did.krate == LOCAL_CRATE { let mut acc = Vec::new(); ty::each_attr(tcx, did, |meta| { acc.extend(attr::find_repr_attrs(tcx.sess.diagnostic(), meta).into_iter()); true }); acc } else { csearch::get_repr_attrs(&tcx.sess.cstore, did) }) }) } // Look up a field ID, whether or not it's local // Takes a list of type substs in case the struct is generic pub fn lookup_field_type<'tcx>(tcx: &ctxt<'tcx>, struct_id: DefId, id: DefId, substs: &Substs<'tcx>) -> Ty<'tcx> { let ty = if id.krate == ast::LOCAL_CRATE { node_id_to_type(tcx, id.node) } else { let mut tcache = tcx.tcache.borrow_mut(); let pty = tcache.entry(&id).get().unwrap_or_else( |vacant_entry| vacant_entry.insert(csearch::get_field_type(tcx, struct_id, id))); pty.ty }; ty.subst(tcx, substs) } // Look up the list of field names and IDs for a given struct. // Panics if the id is not bound to a struct. pub fn lookup_struct_fields(cx: &ctxt, did: ast::DefId) -> Vec { if did.krate == ast::LOCAL_CRATE { let struct_fields = cx.struct_fields.borrow(); match struct_fields.get(&did) { Some(fields) => (**fields).clone(), _ => { cx.sess.bug( format!("ID not mapped to struct fields: {}", cx.map.node_to_string(did.node))[]); } } } else { csearch::get_struct_fields(&cx.sess.cstore, did) } } pub fn is_tuple_struct(cx: &ctxt, did: ast::DefId) -> bool { let fields = lookup_struct_fields(cx, did); !fields.is_empty() && fields.iter().all(|f| f.name == token::special_names::unnamed_field) } // Returns a list of fields corresponding to the struct's items. trans uses // this. Takes a list of substs with which to instantiate field types. pub fn struct_fields<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId, substs: &Substs<'tcx>) -> Vec> { lookup_struct_fields(cx, did).iter().map(|f| { field { name: f.name, mt: mt { ty: lookup_field_type(cx, did, f.id, substs), mutbl: MutImmutable } } }).collect() } // Returns a list of fields corresponding to the tuple's items. trans uses // this. pub fn tup_fields<'tcx>(v: &[Ty<'tcx>]) -> Vec> { v.iter().enumerate().map(|(i, &f)| { field { name: token::intern(i.to_string()[]), mt: mt { ty: f, mutbl: MutImmutable } } }).collect() } #[derive(Copy, Clone)] pub struct UnboxedClosureUpvar<'tcx> { pub def: def::Def, pub span: Span, pub ty: Ty<'tcx>, } // Returns a list of `UnboxedClosureUpvar`s for each upvar. pub fn unboxed_closure_upvars<'tcx>(typer: &mc::Typer<'tcx>, closure_id: ast::DefId, substs: &Substs<'tcx>) -> Option>> { // Presently an unboxed closure type cannot "escape" out of a // function, so we will only encounter ones that originated in the // local crate or were inlined into it along with some function. // This may change if abstract return types of some sort are // implemented. assert!(closure_id.krate == ast::LOCAL_CRATE); let tcx = typer.tcx(); let capture_mode = tcx.capture_modes.borrow()[closure_id.node].clone(); match tcx.freevars.borrow().get(&closure_id.node) { None => Some(vec![]), Some(ref freevars) => { freevars.iter() .map(|freevar| { let freevar_def_id = freevar.def.def_id(); let freevar_ty = match typer.node_ty(freevar_def_id.node) { Ok(t) => { t } Err(()) => { return None; } }; let freevar_ty = freevar_ty.subst(tcx, substs); match capture_mode { ast::CaptureByValue => { Some(UnboxedClosureUpvar { def: freevar.def, span: freevar.span, ty: freevar_ty }) } ast::CaptureByRef => { let upvar_id = ty::UpvarId { var_id: freevar_def_id.node, closure_expr_id: closure_id.node }; // FIXME let freevar_ref_ty = match typer.upvar_borrow(upvar_id) { Some(borrow) => { mk_rptr(tcx, tcx.mk_region(borrow.region), ty::mt { ty: freevar_ty, mutbl: borrow.kind.to_mutbl_lossy(), }) } None => { // FIXME(#16640) we should really return None here; // but that requires better inference integration, // for now gin up something. freevar_ty } }; Some(UnboxedClosureUpvar { def: freevar.def, span: freevar.span, ty: freevar_ref_ty, }) } } }) .collect() } } } pub fn is_binopable<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, op: ast::BinOp) -> bool { #![allow(non_upper_case_globals)] static tycat_other: int = 0; static tycat_bool: int = 1; static tycat_char: int = 2; static tycat_int: int = 3; static tycat_float: int = 4; static tycat_raw_ptr: int = 6; static opcat_add: int = 0; static opcat_sub: int = 1; static opcat_mult: int = 2; static opcat_shift: int = 3; static opcat_rel: int = 4; static opcat_eq: int = 5; static opcat_bit: int = 6; static opcat_logic: int = 7; static opcat_mod: int = 8; fn opcat(op: ast::BinOp) -> int { match op { ast::BiAdd => opcat_add, ast::BiSub => opcat_sub, ast::BiMul => opcat_mult, ast::BiDiv => opcat_mult, ast::BiRem => opcat_mod, ast::BiAnd => opcat_logic, ast::BiOr => opcat_logic, ast::BiBitXor => opcat_bit, ast::BiBitAnd => opcat_bit, ast::BiBitOr => opcat_bit, ast::BiShl => opcat_shift, ast::BiShr => opcat_shift, ast::BiEq => opcat_eq, ast::BiNe => opcat_eq, ast::BiLt => opcat_rel, ast::BiLe => opcat_rel, ast::BiGe => opcat_rel, ast::BiGt => opcat_rel } } fn tycat<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> int { if type_is_simd(cx, ty) { return tycat(cx, simd_type(cx, ty)) } match ty.sty { ty_char => tycat_char, ty_bool => tycat_bool, ty_int(_) | ty_uint(_) | ty_infer(IntVar(_)) => tycat_int, ty_float(_) | ty_infer(FloatVar(_)) => tycat_float, ty_ptr(_) => tycat_raw_ptr, _ => tycat_other } } static t: bool = true; static f: bool = false; let tbl = [ // +, -, *, shift, rel, ==, bit, logic, mod /*other*/ [f, f, f, f, f, f, f, f, f], /*bool*/ [f, f, f, f, t, t, t, t, f], /*char*/ [f, f, f, f, t, t, f, f, f], /*int*/ [t, t, t, t, t, t, t, f, t], /*float*/ [t, t, t, f, t, t, f, f, f], /*bot*/ [t, t, t, t, t, t, t, t, t], /*raw ptr*/ [f, f, f, f, t, t, f, f, f]]; return tbl[tycat(cx, ty) as uint ][opcat(op) as uint]; } /// Returns an equivalent type with all the typedefs and self regions removed. pub fn normalize_ty<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { let u = TypeNormalizer(cx).fold_ty(ty); return u; struct TypeNormalizer<'a, 'tcx: 'a>(&'a ctxt<'tcx>); impl<'a, 'tcx> TypeFolder<'tcx> for TypeNormalizer<'a, 'tcx> { fn tcx(&self) -> &ctxt<'tcx> { let TypeNormalizer(c) = *self; c } fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> { match self.tcx().normalized_cache.borrow().get(&ty).cloned() { None => {} Some(u) => return u } let t_norm = ty_fold::super_fold_ty(self, ty); self.tcx().normalized_cache.borrow_mut().insert(ty, t_norm); return t_norm; } fn fold_region(&mut self, _: ty::Region) -> ty::Region { ty::ReStatic } fn fold_substs(&mut self, substs: &subst::Substs<'tcx>) -> subst::Substs<'tcx> { subst::Substs { regions: subst::ErasedRegions, types: substs.types.fold_with(self) } } } } // Returns the repeat count for a repeating vector expression. pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> uint { match const_eval::eval_const_expr_partial(tcx, count_expr) { Ok(val) => { let found = match val { const_eval::const_uint(count) => return count as uint, const_eval::const_int(count) if count >= 0 => return count as uint, const_eval::const_int(_) => "negative integer", const_eval::const_float(_) => "float", const_eval::const_str(_) => "string", const_eval::const_bool(_) => "boolean", const_eval::const_binary(_) => "binary array" }; tcx.sess.span_err(count_expr.span, format!( "expected positive integer for repeat count, found {}", found)[]); } Err(_) => { let found = match count_expr.node { ast::ExprPath(ast::Path { global: false, ref segments, .. }) if segments.len() == 1 => "variable", _ => "non-constant expression" }; tcx.sess.span_err(count_expr.span, format!( "expected constant integer for repeat count, found {}", found)[]); } } 0 } // Iterate over a type parameter's bounded traits and any supertraits // of those traits, ignoring kinds. // Here, the supertraits are the transitive closure of the supertrait // relation on the supertraits from each bounded trait's constraint // list. pub fn each_bound_trait_and_supertraits<'tcx, F>(tcx: &ctxt<'tcx>, bounds: &[PolyTraitRef<'tcx>], mut f: F) -> bool where F: FnMut(PolyTraitRef<'tcx>) -> bool, { for bound_trait_ref in traits::transitive_bounds(tcx, bounds) { if !f(bound_trait_ref) { return false; } } return true; } pub fn object_region_bounds<'tcx>( tcx: &ctxt<'tcx>, opt_principal: Option<&PolyTraitRef<'tcx>>, // None for closures others: BuiltinBounds) -> Vec { // Since we don't actually *know* the self type for an object, // this "open(err)" serves as a kind of dummy standin -- basically // a skolemized type. let open_ty = ty::mk_infer(tcx, FreshTy(0)); let opt_trait_ref = opt_principal.map_or(Vec::new(), |principal| { // Note that we preserve the overall binding levels here. assert!(!open_ty.has_escaping_regions()); let substs = tcx.mk_substs(principal.0.substs.with_self_ty(open_ty)); vec!(ty::Binder(Rc::new(ty::TraitRef::new(principal.0.def_id, substs)))) }); let param_bounds = ty::ParamBounds { region_bounds: Vec::new(), builtin_bounds: others, trait_bounds: opt_trait_ref, projection_bounds: Vec::new(), // not relevant to computing region bounds }; let predicates = ty::predicates(tcx, open_ty, ¶m_bounds); ty::required_region_bounds(tcx, open_ty, predicates) } /// Given a set of predicates that apply to an object type, returns /// the region bounds that the (erased) `Self` type must /// outlive. Precisely *because* the `Self` type is erased, the /// parameter `erased_self_ty` must be supplied to indicate what type /// has been used to represent `Self` in the predicates /// themselves. This should really be a unique type; `FreshTy(0)` is a /// popular choice (see `object_region_bounds` above). /// /// Requires that trait definitions have been processed so that we can /// elaborate predicates and walk supertraits. pub fn required_region_bounds<'tcx>(tcx: &ctxt<'tcx>, erased_self_ty: Ty<'tcx>, predicates: Vec>) -> Vec { debug!("required_region_bounds(erased_self_ty={}, predicates={})", erased_self_ty.repr(tcx), predicates.repr(tcx)); assert!(!erased_self_ty.has_escaping_regions()); traits::elaborate_predicates(tcx, predicates) .filter_map(|predicate| { match predicate { ty::Predicate::Projection(..) | ty::Predicate::Trait(..) | ty::Predicate::Equate(..) | ty::Predicate::RegionOutlives(..) => { None } ty::Predicate::TypeOutlives(ty::Binder(ty::OutlivesPredicate(t, r))) => { // Search for a bound of the form `erased_self_ty // : 'a`, but be wary of something like `for<'a> // erased_self_ty : 'a` (we interpret a // higher-ranked bound like that as 'static, // though at present the code in `fulfill.rs` // considers such bounds to be unsatisfiable, so // it's kind of a moot point since you could never // construct such an object, but this seems // correct even if that code changes). if t == erased_self_ty && !r.has_escaping_regions() { if r.has_escaping_regions() { Some(ty::ReStatic) } else { Some(r) } } else { None } } } }) .collect() } pub fn get_tydesc_ty<'tcx>(tcx: &ctxt<'tcx>) -> Result, String> { tcx.lang_items.require(TyDescStructLangItem).map(|tydesc_lang_item| { tcx.intrinsic_defs.borrow().get(&tydesc_lang_item).cloned() .expect("Failed to resolve TyDesc") }) } pub fn item_variances(tcx: &ctxt, item_id: ast::DefId) -> Rc { lookup_locally_or_in_crate_store( "item_variance_map", item_id, &mut *tcx.item_variance_map.borrow_mut(), || Rc::new(csearch::get_item_variances(&tcx.sess.cstore, item_id))) } /// Records a trait-to-implementation mapping. pub fn record_trait_implementation(tcx: &ctxt, trait_def_id: DefId, impl_def_id: DefId) { match tcx.trait_impls.borrow().get(&trait_def_id) { Some(impls_for_trait) => { impls_for_trait.borrow_mut().push(impl_def_id); return; } None => {} } tcx.trait_impls.borrow_mut().insert(trait_def_id, Rc::new(RefCell::new(vec!(impl_def_id)))); } /// Populates the type context with all the implementations for the given type /// if necessary. pub fn populate_implementations_for_type_if_necessary(tcx: &ctxt, type_id: ast::DefId) { if type_id.krate == LOCAL_CRATE { return } if tcx.populated_external_types.borrow().contains(&type_id) { return } debug!("populate_implementations_for_type_if_necessary: searching for {}", type_id); let mut inherent_impls = Vec::new(); csearch::each_implementation_for_type(&tcx.sess.cstore, type_id, |impl_def_id| { let impl_items = csearch::get_impl_items(&tcx.sess.cstore, impl_def_id); // Record the trait->implementation mappings, if applicable. let associated_traits = csearch::get_impl_trait(tcx, impl_def_id); for trait_ref in associated_traits.iter() { record_trait_implementation(tcx, trait_ref.def_id, impl_def_id); } // For any methods that use a default implementation, add them to // the map. This is a bit unfortunate. for impl_item_def_id in impl_items.iter() { let method_def_id = impl_item_def_id.def_id(); match impl_or_trait_item(tcx, method_def_id) { MethodTraitItem(method) => { for &source in method.provided_source.iter() { tcx.provided_method_sources .borrow_mut() .insert(method_def_id, source); } } TypeTraitItem(_) => {} } } // Store the implementation info. tcx.impl_items.borrow_mut().insert(impl_def_id, impl_items); // If this is an inherent implementation, record it. if associated_traits.is_none() { inherent_impls.push(impl_def_id); } }); tcx.inherent_impls.borrow_mut().insert(type_id, Rc::new(inherent_impls)); tcx.populated_external_types.borrow_mut().insert(type_id); } /// Populates the type context with all the implementations for the given /// trait if necessary. pub fn populate_implementations_for_trait_if_necessary( tcx: &ctxt, trait_id: ast::DefId) { if trait_id.krate == LOCAL_CRATE { return } if tcx.populated_external_traits.borrow().contains(&trait_id) { return } csearch::each_implementation_for_trait(&tcx.sess.cstore, trait_id, |implementation_def_id| { let impl_items = csearch::get_impl_items(&tcx.sess.cstore, implementation_def_id); // Record the trait->implementation mapping. record_trait_implementation(tcx, trait_id, implementation_def_id); // For any methods that use a default implementation, add them to // the map. This is a bit unfortunate. for impl_item_def_id in impl_items.iter() { let method_def_id = impl_item_def_id.def_id(); match impl_or_trait_item(tcx, method_def_id) { MethodTraitItem(method) => { for &source in method.provided_source.iter() { tcx.provided_method_sources .borrow_mut() .insert(method_def_id, source); } } TypeTraitItem(_) => {} } } // Store the implementation info. tcx.impl_items.borrow_mut().insert(implementation_def_id, impl_items); }); tcx.populated_external_traits.borrow_mut().insert(trait_id); } /// Given the def_id of an impl, return the def_id of the trait it implements. /// If it implements no trait, return `None`. pub fn trait_id_of_impl(tcx: &ctxt, def_id: ast::DefId) -> Option { ty::impl_trait_ref(tcx, def_id).map(|tr| tr.def_id) } /// If the given def ID describes a method belonging to an impl, return the /// ID of the impl that the method belongs to. Otherwise, return `None`. pub fn impl_of_method(tcx: &ctxt, def_id: ast::DefId) -> Option { if def_id.krate != LOCAL_CRATE { return match csearch::get_impl_or_trait_item(tcx, def_id).container() { TraitContainer(_) => None, ImplContainer(def_id) => Some(def_id), }; } match tcx.impl_or_trait_items.borrow().get(&def_id).cloned() { Some(trait_item) => { match trait_item.container() { TraitContainer(_) => None, ImplContainer(def_id) => Some(def_id), } } None => None } } /// If the given def ID describes an item belonging to a trait (either a /// default method or an implementation of a trait method), return the ID of /// the trait that the method belongs to. Otherwise, return `None`. pub fn trait_of_item(tcx: &ctxt, def_id: ast::DefId) -> Option { if def_id.krate != LOCAL_CRATE { return csearch::get_trait_of_item(&tcx.sess.cstore, def_id, tcx); } match tcx.impl_or_trait_items.borrow().get(&def_id).cloned() { Some(impl_or_trait_item) => { match impl_or_trait_item.container() { TraitContainer(def_id) => Some(def_id), ImplContainer(def_id) => trait_id_of_impl(tcx, def_id), } } None => None } } /// If the given def ID describes an item belonging to a trait, (either a /// default method or an implementation of a trait method), return the ID of /// the method inside trait definition (this means that if the given def ID /// is already that of the original trait method, then the return value is /// the same). /// Otherwise, return `None`. pub fn trait_item_of_item(tcx: &ctxt, def_id: ast::DefId) -> Option { let impl_item = match tcx.impl_or_trait_items.borrow().get(&def_id) { Some(m) => m.clone(), None => return None, }; let name = impl_item.name(); match trait_of_item(tcx, def_id) { Some(trait_did) => { let trait_items = ty::trait_items(tcx, trait_did); trait_items.iter() .position(|m| m.name() == name) .map(|idx| ty::trait_item(tcx, trait_did, idx).id()) } None => None } } /// Creates a hash of the type `Ty` which will be the same no matter what crate /// context it's calculated within. This is used by the `type_id` intrinsic. pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) -> u64 { let mut state = sip::SipState::new(); helper(tcx, ty, svh, &mut state); return state.result(); fn helper<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh, state: &mut sip::SipState) { macro_rules! byte { ($b:expr) => { ($b as u8).hash(state) } } macro_rules! hash { ($e:expr) => { $e.hash(state) } } let region = |&: state: &mut sip::SipState, r: Region| { match r { ReStatic => {} ReLateBound(db, BrAnon(i)) => { db.hash(state); i.hash(state); } ReEmpty | ReEarlyBound(..) | ReLateBound(..) | ReFree(..) | ReScope(..) | ReInfer(..) => { tcx.sess.bug("unexpected region found when hashing a type") } } }; let did = |&: state: &mut sip::SipState, did: DefId| { let h = if ast_util::is_local(did) { svh.clone() } else { tcx.sess.cstore.get_crate_hash(did.krate) }; h.as_str().hash(state); did.node.hash(state); }; let mt = |&: state: &mut sip::SipState, mt: mt| { mt.mutbl.hash(state); }; let fn_sig = |&: state: &mut sip::SipState, sig: &Binder>| { let sig = anonymize_late_bound_regions(tcx, sig); for a in sig.inputs.iter() { helper(tcx, *a, svh, state); } if let ty::FnConverging(output) = sig.output { helper(tcx, output, svh, state); } }; maybe_walk_ty(ty, |ty| { match ty.sty { ty_bool => byte!(2), ty_char => byte!(3), ty_int(i) => { byte!(4); hash!(i); } ty_uint(u) => { byte!(5); hash!(u); } ty_float(f) => { byte!(6); hash!(f); } ty_str => { byte!(7); } ty_enum(d, _) => { byte!(8); did(state, d); } ty_uniq(_) => { byte!(9); } ty_vec(_, Some(n)) => { byte!(10); n.hash(state); } ty_vec(_, None) => { byte!(11); } ty_ptr(m) => { byte!(12); mt(state, m); } ty_rptr(r, m) => { byte!(13); region(state, *r); mt(state, m); } ty_bare_fn(opt_def_id, ref b) => { byte!(14); hash!(opt_def_id); hash!(b.unsafety); hash!(b.abi); fn_sig(state, &b.sig); return false; } ty_trait(ref data) => { byte!(17); did(state, data.principal_def_id()); hash!(data.bounds); let principal = anonymize_late_bound_regions(tcx, &data.principal); for subty in principal.substs.types.iter() { helper(tcx, *subty, svh, state); } return false; } ty_struct(d, _) => { byte!(18); did(state, d); } ty_tup(ref inner) => { byte!(19); hash!(inner.len()); } ty_param(p) => { byte!(20); hash!(p.space); hash!(p.idx); hash!(token::get_name(p.name)); } ty_open(_) => byte!(22), ty_infer(_) => unreachable!(), ty_err => byte!(23), ty_unboxed_closure(d, r, _) => { byte!(24); did(state, d); region(state, *r); } ty_projection(ref data) => { byte!(25); did(state, data.trait_ref.def_id); hash!(token::get_name(data.item_name)); } } true }); } } impl Variance { pub fn to_string(self) -> &'static str { match self { Covariant => "+", Contravariant => "-", Invariant => "o", Bivariant => "*", } } } /// Construct a parameter environment suitable for static contexts or other contexts where there /// are no free type/lifetime parameters in scope. pub fn empty_parameter_environment<'a,'tcx>(cx: &'a ctxt<'tcx>) -> ParameterEnvironment<'a,'tcx> { ty::ParameterEnvironment { tcx: cx, free_substs: Substs::empty(), caller_bounds: GenericBounds::empty(), implicit_region_bound: ty::ReEmpty, selection_cache: traits::SelectionCache::new(), } } /// See `ParameterEnvironment` struct def'n for details pub fn construct_parameter_environment<'a,'tcx>( tcx: &'a ctxt<'tcx>, generics: &ty::Generics<'tcx>, free_id: ast::NodeId) -> ParameterEnvironment<'a, 'tcx> { // // Construct the free substs. // // map T => T let mut types = VecPerParamSpace::empty(); push_types_from_defs(tcx, &mut types, generics.types.as_slice()); // map bound 'a => free 'a let mut regions = VecPerParamSpace::empty(); push_region_params(&mut regions, free_id, generics.regions.as_slice()); let free_substs = Substs { types: types, regions: subst::NonerasedRegions(regions) }; let free_id_scope = region::CodeExtent::from_node_id(free_id); // // Compute the bounds on Self and the type parameters. // let bounds = generics.to_bounds(tcx, &free_substs); let bounds = liberate_late_bound_regions(tcx, free_id_scope, &ty::Binder(bounds)); // // Compute region bounds. For now, these relations are stored in a // global table on the tcx, so just enter them there. I'm not // crazy about this scheme, but it's convenient, at least. // record_region_bounds(tcx, &bounds); debug!("construct_parameter_environment: free_id={} free_subst={} bounds={}", free_id, free_substs.repr(tcx), bounds.repr(tcx)); return ty::ParameterEnvironment { tcx: tcx, free_substs: free_substs, implicit_region_bound: ty::ReScope(free_id_scope), caller_bounds: bounds, selection_cache: traits::SelectionCache::new(), }; fn push_region_params(regions: &mut VecPerParamSpace, free_id: ast::NodeId, region_params: &[RegionParameterDef]) { for r in region_params.iter() { regions.push(r.space, ty::free_region_from_def(free_id, r)); } } fn push_types_from_defs<'tcx>(tcx: &ty::ctxt<'tcx>, types: &mut VecPerParamSpace>, defs: &[TypeParameterDef<'tcx>]) { for def in defs.iter() { debug!("construct_parameter_environment(): push_types_from_defs: def={}", def.repr(tcx)); let ty = ty::mk_param_from_def(tcx, def); types.push(def.space, ty); } } fn record_region_bounds<'tcx>(tcx: &ty::ctxt<'tcx>, bounds: &GenericBounds<'tcx>) { debug!("record_region_bounds(bounds={})", bounds.repr(tcx)); for predicate in bounds.predicates.iter() { match *predicate { Predicate::Projection(..) | Predicate::Trait(..) | Predicate::Equate(..) | Predicate::TypeOutlives(..) => { // No region bounds here } Predicate::RegionOutlives(ty::Binder(ty::OutlivesPredicate(r_a, r_b))) => { match (r_a, r_b) { (ty::ReFree(fr_a), ty::ReFree(fr_b)) => { // Record that `'a:'b`. Or, put another way, `'b <= 'a`. tcx.region_maps.relate_free_regions(fr_b, fr_a); } _ => { // All named regions are instantiated with free regions. tcx.sess.bug( format!("record_region_bounds: non free region: {} / {}", r_a.repr(tcx), r_b.repr(tcx)).as_slice()); } } } } } } } impl BorrowKind { pub fn from_mutbl(m: ast::Mutability) -> BorrowKind { match m { ast::MutMutable => MutBorrow, ast::MutImmutable => ImmBorrow, } } /// Returns a mutability `m` such that an `&m T` pointer could be used to obtain this borrow /// kind. Because borrow kinds are richer than mutabilities, we sometimes have to pick a /// mutability that is stronger than necessary so that it at least *would permit* the borrow in /// question. pub fn to_mutbl_lossy(self) -> ast::Mutability { match self { MutBorrow => ast::MutMutable, ImmBorrow => ast::MutImmutable, // We have no type corresponding to a unique imm borrow, so // use `&mut`. It gives all the capabilities of an `&uniq` // and hence is a safe "over approximation". UniqueImmBorrow => ast::MutMutable, } } pub fn to_user_str(&self) -> &'static str { match *self { MutBorrow => "mutable", ImmBorrow => "immutable", UniqueImmBorrow => "uniquely immutable", } } } impl<'tcx> ctxt<'tcx> { pub fn capture_mode(&self, closure_expr_id: ast::NodeId) -> ast::CaptureClause { self.capture_modes.borrow()[closure_expr_id].clone() } pub fn is_method_call(&self, expr_id: ast::NodeId) -> bool { self.method_map.borrow().contains_key(&MethodCall::expr(expr_id)) } } impl<'a,'tcx> mc::Typer<'tcx> for ParameterEnvironment<'a,'tcx> { fn tcx(&self) -> &ty::ctxt<'tcx> { self.tcx } fn node_ty(&self, id: ast::NodeId) -> mc::McResult> { Ok(ty::node_id_to_type(self.tcx, id)) } fn expr_ty_adjusted(&self, expr: &ast::Expr) -> mc::McResult> { Ok(ty::expr_ty_adjusted(self.tcx, expr)) } fn node_method_ty(&self, method_call: ty::MethodCall) -> Option> { self.tcx.method_map.borrow().get(&method_call).map(|method| method.ty) } fn node_method_origin(&self, method_call: ty::MethodCall) -> Option> { self.tcx.method_map.borrow().get(&method_call).map(|method| method.origin.clone()) } fn adjustments(&self) -> &RefCell>> { &self.tcx.adjustments } fn is_method_call(&self, id: ast::NodeId) -> bool { self.tcx.is_method_call(id) } fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option { self.tcx.region_maps.temporary_scope(rvalue_id) } fn upvar_borrow(&self, upvar_id: ty::UpvarId) -> Option { Some(self.tcx.upvar_borrow_map.borrow()[upvar_id].clone()) } fn capture_mode(&self, closure_expr_id: ast::NodeId) -> ast::CaptureClause { self.tcx.capture_mode(closure_expr_id) } fn type_moves_by_default(&self, span: Span, ty: Ty<'tcx>) -> bool { type_moves_by_default(self, span, ty) } } impl<'a,'tcx> UnboxedClosureTyper<'tcx> for ty::ParameterEnvironment<'a,'tcx> { fn param_env<'b>(&'b self) -> &'b ty::ParameterEnvironment<'b,'tcx> { self } fn unboxed_closure_kind(&self, def_id: ast::DefId) -> ty::UnboxedClosureKind { self.tcx.unboxed_closure_kind(def_id) } fn unboxed_closure_type(&self, def_id: ast::DefId, substs: &subst::Substs<'tcx>) -> ty::ClosureTy<'tcx> { self.tcx.unboxed_closure_type(def_id, substs) } fn unboxed_closure_upvars(&self, def_id: ast::DefId, substs: &Substs<'tcx>) -> Option>> { unboxed_closure_upvars(self, def_id, substs) } } /// The category of explicit self. #[derive(Clone, Copy, Eq, PartialEq, Show)] pub enum ExplicitSelfCategory { StaticExplicitSelfCategory, ByValueExplicitSelfCategory, ByReferenceExplicitSelfCategory(Region, ast::Mutability), ByBoxExplicitSelfCategory, } /// Pushes all the lifetimes in the given type onto the given list. A /// "lifetime in a type" is a lifetime specified by a reference or a lifetime /// in a list of type substitutions. This does *not* traverse into nominal /// types, nor does it resolve fictitious types. pub fn accumulate_lifetimes_in_type(accumulator: &mut Vec, ty: Ty) { walk_ty(ty, |ty| { match ty.sty { ty_rptr(region, _) => { accumulator.push(*region) } ty_trait(ref t) => { accumulator.push_all(t.principal.0.substs.regions().as_slice()); } ty_enum(_, substs) | ty_struct(_, substs) => { accum_substs(accumulator, substs); } ty_unboxed_closure(_, region, substs) => { accumulator.push(*region); accum_substs(accumulator, substs); } ty_bool | ty_char | ty_int(_) | ty_uint(_) | ty_float(_) | ty_uniq(_) | ty_str | ty_vec(_, _) | ty_ptr(_) | ty_bare_fn(..) | ty_tup(_) | ty_projection(_) | ty_param(_) | ty_infer(_) | ty_open(_) | ty_err => { } } }); fn accum_substs(accumulator: &mut Vec, substs: &Substs) { match substs.regions { subst::ErasedRegions => {} subst::NonerasedRegions(ref regions) => { for region in regions.iter() { accumulator.push(*region) } } } } } /// A free variable referred to in a function. #[derive(Copy, RustcEncodable, RustcDecodable)] pub struct Freevar { /// The variable being accessed free. pub def: def::Def, // First span where it is accessed (there can be multiple). pub span: Span } pub type FreevarMap = NodeMap>; pub type CaptureModeMap = NodeMap; // Trait method resolution pub type TraitMap = NodeMap>; // Map from the NodeId of a glob import to a list of items which are actually // imported. pub type GlobMap = HashMap>; pub fn with_freevars(tcx: &ty::ctxt, fid: ast::NodeId, f: F) -> T where F: FnOnce(&[Freevar]) -> T, { match tcx.freevars.borrow().get(&fid) { None => f(&[]), Some(d) => f(d[]) } } impl<'tcx> AutoAdjustment<'tcx> { pub fn is_identity(&self) -> bool { match *self { AdjustReifyFnPointer(..) => false, AdjustDerefRef(ref r) => r.is_identity(), } } } impl<'tcx> AutoDerefRef<'tcx> { pub fn is_identity(&self) -> bool { self.autoderefs == 0 && self.autoref.is_none() } } /// Replace any late-bound regions bound in `value` with free variants attached to scope-id /// `scope_id`. pub fn liberate_late_bound_regions<'tcx, T>( tcx: &ty::ctxt<'tcx>, scope: region::CodeExtent, value: &Binder) -> T where T : TypeFoldable<'tcx> + Repr<'tcx> { replace_late_bound_regions( tcx, value, |br, _| ty::ReFree(ty::FreeRegion{scope: scope, bound_region: br})).0 } pub fn count_late_bound_regions<'tcx, T>( tcx: &ty::ctxt<'tcx>, value: &Binder) -> uint where T : TypeFoldable<'tcx> + Repr<'tcx> { let (_, skol_map) = replace_late_bound_regions(tcx, value, |_, _| ty::ReStatic); skol_map.len() } pub fn binds_late_bound_regions<'tcx, T>( tcx: &ty::ctxt<'tcx>, value: &Binder) -> bool where T : TypeFoldable<'tcx> + Repr<'tcx> { count_late_bound_regions(tcx, value) > 0 } /// Replace any late-bound regions bound in `value` with `'static`. Useful in trans but also /// method lookup and a few other places where precise region relationships are not required. pub fn erase_late_bound_regions<'tcx, T>( tcx: &ty::ctxt<'tcx>, value: &Binder) -> T where T : TypeFoldable<'tcx> + Repr<'tcx> { replace_late_bound_regions(tcx, value, |_, _| ty::ReStatic).0 } /// Rewrite any late-bound regions so that they are anonymous. Region numbers are /// assigned starting at 1 and increasing monotonically in the order traversed /// by the fold operation. /// /// The chief purpose of this function is to canonicalize regions so that two /// `FnSig`s or `TraitRef`s which are equivalent up to region naming will become /// structurally identical. For example, `for<'a, 'b> fn(&'a int, &'b int)` and /// `for<'a, 'b> fn(&'b int, &'a int)` will become identical after anonymization. pub fn anonymize_late_bound_regions<'tcx, T>( tcx: &ctxt<'tcx>, sig: &Binder) -> T where T : TypeFoldable<'tcx> + Repr<'tcx>, { let mut counter = 0; replace_late_bound_regions(tcx, sig, |_, db| { counter += 1; ReLateBound(db, BrAnon(counter)) }).0 } /// Replaces the late-bound-regions in `value` that are bound by `value`. pub fn replace_late_bound_regions<'tcx, T, F>( tcx: &ty::ctxt<'tcx>, binder: &Binder, mut mapf: F) -> (T, FnvHashMap) where T : TypeFoldable<'tcx> + Repr<'tcx>, F : FnMut(BoundRegion, DebruijnIndex) -> ty::Region, { debug!("replace_late_bound_regions({})", binder.repr(tcx)); let mut map = FnvHashMap::new(); // Note: fold the field `0`, not the binder, so that late-bound // regions bound by `binder` are considered free. let value = ty_fold::fold_regions(tcx, &binder.0, |region, current_depth| { debug!("region={}", region.repr(tcx)); match region { ty::ReLateBound(debruijn, br) if debruijn.depth == current_depth => { * map.entry(&br).get().unwrap_or_else( |vacant_entry| vacant_entry.insert(mapf(br, debruijn))) } _ => { region } } }); debug!("resulting map: {} value: {}", map, value.repr(tcx)); (value, map) } impl DebruijnIndex { pub fn new(depth: u32) -> DebruijnIndex { assert!(depth > 0); DebruijnIndex { depth: depth } } pub fn shifted(&self, amount: u32) -> DebruijnIndex { DebruijnIndex { depth: self.depth + amount } } } impl<'tcx> Repr<'tcx> for AutoAdjustment<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { match *self { AdjustReifyFnPointer(def_id) => { format!("AdjustReifyFnPointer({})", def_id.repr(tcx)) } AdjustDerefRef(ref data) => { data.repr(tcx) } } } } impl<'tcx> Repr<'tcx> for UnsizeKind<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { match *self { UnsizeLength(n) => format!("UnsizeLength({})", n), UnsizeStruct(ref k, n) => format!("UnsizeStruct({},{})", k.repr(tcx), n), UnsizeVtable(ref a, ref b) => format!("UnsizeVtable({},{})", a.repr(tcx), b.repr(tcx)), } } } impl<'tcx> Repr<'tcx> for AutoDerefRef<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { format!("AutoDerefRef({}, {})", self.autoderefs, self.autoref.repr(tcx)) } } impl<'tcx> Repr<'tcx> for AutoRef<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { match *self { AutoPtr(a, b, ref c) => { format!("AutoPtr({},{},{})", a.repr(tcx), b, c.repr(tcx)) } AutoUnsize(ref a) => { format!("AutoUnsize({})", a.repr(tcx)) } AutoUnsizeUniq(ref a) => { format!("AutoUnsizeUniq({})", a.repr(tcx)) } AutoUnsafe(ref a, ref b) => { format!("AutoUnsafe({},{})", a, b.repr(tcx)) } } } } impl<'tcx> Repr<'tcx> for TyTrait<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { format!("TyTrait({},{})", self.principal.repr(tcx), self.bounds.repr(tcx)) } } impl<'tcx> Repr<'tcx> for ty::Predicate<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { match *self { Predicate::Trait(ref a) => a.repr(tcx), Predicate::Equate(ref pair) => pair.repr(tcx), Predicate::RegionOutlives(ref pair) => pair.repr(tcx), Predicate::TypeOutlives(ref pair) => pair.repr(tcx), Predicate::Projection(ref pair) => pair.repr(tcx), } } } impl<'tcx> Repr<'tcx> for vtable_origin<'tcx> { fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String { match *self { vtable_static(def_id, ref tys, ref vtable_res) => { format!("vtable_static({}:{}, {}, {})", def_id, ty::item_path_str(tcx, def_id), tys.repr(tcx), vtable_res.repr(tcx)) } vtable_param(x, y) => { format!("vtable_param({}, {})", x, y) } vtable_unboxed_closure(def_id) => { format!("vtable_unboxed_closure({})", def_id) } vtable_error => { format!("vtable_error") } } } } pub fn make_substs_for_receiver_types<'tcx>(tcx: &ty::ctxt<'tcx>, trait_ref: &ty::TraitRef<'tcx>, method: &ty::Method<'tcx>) -> subst::Substs<'tcx> { /*! * Substitutes the values for the receiver's type parameters * that are found in method, leaving the method's type parameters * intact. */ let meth_tps: Vec = method.generics.types.get_slice(subst::FnSpace) .iter() .map(|def| ty::mk_param_from_def(tcx, def)) .collect(); let meth_regions: Vec = method.generics.regions.get_slice(subst::FnSpace) .iter() .map(|def| ty::ReEarlyBound(def.def_id.node, def.space, def.index, def.name)) .collect(); trait_ref.substs.clone().with_method(meth_tps, meth_regions) } #[derive(Copy)] pub enum CopyImplementationError { FieldDoesNotImplementCopy(ast::Name), VariantDoesNotImplementCopy(ast::Name), TypeIsStructural, } pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tcx>, span: Span, self_type: Ty<'tcx>) -> Result<(),CopyImplementationError> { let tcx = param_env.tcx; match self_type.sty { ty::ty_struct(struct_did, substs) => { let fields = ty::struct_fields(tcx, struct_did, substs); for field in fields.iter() { if type_moves_by_default(param_env, span, field.mt.ty) { return Err(FieldDoesNotImplementCopy(field.name)) } } } ty::ty_enum(enum_did, substs) => { let enum_variants = ty::enum_variants(tcx, enum_did); for variant in enum_variants.iter() { for variant_arg_type in variant.args.iter() { let substd_arg_type = variant_arg_type.subst(tcx, substs); if type_moves_by_default(param_env, span, substd_arg_type) { return Err(VariantDoesNotImplementCopy(variant.name)) } } } } _ => return Err(TypeIsStructural), } Ok(()) } // FIXME(#20298) -- all of these types basically walk various // structures to test whether types/regions are reachable with various // properties. It should be possible to express them in terms of one // common "walker" trait or something. pub trait RegionEscape { fn has_escaping_regions(&self) -> bool { self.has_regions_escaping_depth(0) } fn has_regions_escaping_depth(&self, depth: u32) -> bool; } impl<'tcx> RegionEscape for Ty<'tcx> { fn has_regions_escaping_depth(&self, depth: u32) -> bool { ty::type_escapes_depth(*self, depth) } } impl<'tcx,T:RegionEscape> RegionEscape for VecPerParamSpace { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.iter_enumerated().any(|(space, _, t)| { if space == subst::FnSpace { t.has_regions_escaping_depth(depth+1) } else { t.has_regions_escaping_depth(depth) } }) } } impl<'tcx> RegionEscape for TypeScheme<'tcx> { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.ty.has_regions_escaping_depth(depth) || self.generics.has_regions_escaping_depth(depth) } } impl RegionEscape for Region { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.escapes_depth(depth) } } impl<'tcx> RegionEscape for Generics<'tcx> { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.predicates.has_regions_escaping_depth(depth) } } impl<'tcx> RegionEscape for Predicate<'tcx> { fn has_regions_escaping_depth(&self, depth: u32) -> bool { match *self { Predicate::Trait(ref data) => data.has_regions_escaping_depth(depth), Predicate::Equate(ref data) => data.has_regions_escaping_depth(depth), Predicate::RegionOutlives(ref data) => data.has_regions_escaping_depth(depth), Predicate::TypeOutlives(ref data) => data.has_regions_escaping_depth(depth), Predicate::Projection(ref data) => data.has_regions_escaping_depth(depth), } } } impl<'tcx> RegionEscape for TraitRef<'tcx> { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.substs.types.iter().any(|t| t.has_regions_escaping_depth(depth)) || self.substs.regions.has_regions_escaping_depth(depth) } } impl<'tcx> RegionEscape for subst::RegionSubsts { fn has_regions_escaping_depth(&self, depth: u32) -> bool { match *self { subst::ErasedRegions => false, subst::NonerasedRegions(ref r) => { r.iter().any(|t| t.has_regions_escaping_depth(depth)) } } } } impl<'tcx,T:RegionEscape> RegionEscape for Binder { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.0.has_regions_escaping_depth(depth + 1) } } impl<'tcx> RegionEscape for EquatePredicate<'tcx> { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.0.has_regions_escaping_depth(depth) || self.1.has_regions_escaping_depth(depth) } } impl<'tcx> RegionEscape for TraitPredicate<'tcx> { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.trait_ref.has_regions_escaping_depth(depth) } } impl RegionEscape for OutlivesPredicate { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.0.has_regions_escaping_depth(depth) || self.1.has_regions_escaping_depth(depth) } } impl<'tcx> RegionEscape for ProjectionPredicate<'tcx> { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.projection_ty.has_regions_escaping_depth(depth) || self.ty.has_regions_escaping_depth(depth) } } impl<'tcx> RegionEscape for ProjectionTy<'tcx> { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.trait_ref.has_regions_escaping_depth(depth) } } impl<'tcx> Repr<'tcx> for ty::ProjectionPredicate<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { format!("ProjectionPredicate({}, {})", self.projection_ty.repr(tcx), self.ty.repr(tcx)) } } pub trait HasProjectionTypes { fn has_projection_types(&self) -> bool; } impl<'tcx,T:HasProjectionTypes> HasProjectionTypes for Vec { fn has_projection_types(&self) -> bool { self.iter().any(|p| p.has_projection_types()) } } impl<'tcx,T:HasProjectionTypes> HasProjectionTypes for VecPerParamSpace { fn has_projection_types(&self) -> bool { self.iter().any(|p| p.has_projection_types()) } } impl<'tcx> HasProjectionTypes for ClosureTy<'tcx> { fn has_projection_types(&self) -> bool { self.sig.has_projection_types() } } impl<'tcx> HasProjectionTypes for UnboxedClosureUpvar<'tcx> { fn has_projection_types(&self) -> bool { self.ty.has_projection_types() } } impl<'tcx> HasProjectionTypes for ty::GenericBounds<'tcx> { fn has_projection_types(&self) -> bool { self.predicates.has_projection_types() } } impl<'tcx> HasProjectionTypes for Predicate<'tcx> { fn has_projection_types(&self) -> bool { match *self { Predicate::Trait(ref data) => data.has_projection_types(), Predicate::Equate(ref data) => data.has_projection_types(), Predicate::RegionOutlives(ref data) => data.has_projection_types(), Predicate::TypeOutlives(ref data) => data.has_projection_types(), Predicate::Projection(ref data) => data.has_projection_types(), } } } impl<'tcx> HasProjectionTypes for TraitPredicate<'tcx> { fn has_projection_types(&self) -> bool { self.trait_ref.has_projection_types() } } impl<'tcx> HasProjectionTypes for EquatePredicate<'tcx> { fn has_projection_types(&self) -> bool { self.0.has_projection_types() || self.1.has_projection_types() } } impl HasProjectionTypes for Region { fn has_projection_types(&self) -> bool { false } } impl HasProjectionTypes for OutlivesPredicate { fn has_projection_types(&self) -> bool { self.0.has_projection_types() || self.1.has_projection_types() } } impl<'tcx> HasProjectionTypes for ProjectionPredicate<'tcx> { fn has_projection_types(&self) -> bool { self.projection_ty.has_projection_types() || self.ty.has_projection_types() } } impl<'tcx> HasProjectionTypes for ProjectionTy<'tcx> { fn has_projection_types(&self) -> bool { self.trait_ref.has_projection_types() } } impl<'tcx> HasProjectionTypes for Ty<'tcx> { fn has_projection_types(&self) -> bool { ty::type_has_projection(*self) } } impl<'tcx> HasProjectionTypes for TraitRef<'tcx> { fn has_projection_types(&self) -> bool { self.substs.has_projection_types() } } impl<'tcx> HasProjectionTypes for subst::Substs<'tcx> { fn has_projection_types(&self) -> bool { self.types.iter().any(|t| t.has_projection_types()) } } impl<'tcx,T> HasProjectionTypes for Option where T : HasProjectionTypes { fn has_projection_types(&self) -> bool { self.iter().any(|t| t.has_projection_types()) } } impl<'tcx,T> HasProjectionTypes for Rc where T : HasProjectionTypes { fn has_projection_types(&self) -> bool { (**self).has_projection_types() } } impl<'tcx,T> HasProjectionTypes for Box where T : HasProjectionTypes { fn has_projection_types(&self) -> bool { (**self).has_projection_types() } } impl HasProjectionTypes for Binder where T : HasProjectionTypes { fn has_projection_types(&self) -> bool { self.0.has_projection_types() } } impl<'tcx> HasProjectionTypes for FnOutput<'tcx> { fn has_projection_types(&self) -> bool { match *self { FnConverging(t) => t.has_projection_types(), FnDiverging => false, } } } impl<'tcx> HasProjectionTypes for FnSig<'tcx> { fn has_projection_types(&self) -> bool { self.inputs.iter().any(|t| t.has_projection_types()) || self.output.has_projection_types() } } impl<'tcx> HasProjectionTypes for BareFnTy<'tcx> { fn has_projection_types(&self) -> bool { self.sig.has_projection_types() } } pub trait ReferencesError { fn references_error(&self) -> bool; } impl ReferencesError for Binder { fn references_error(&self) -> bool { self.0.references_error() } } impl ReferencesError for Rc { fn references_error(&self) -> bool { (&**self).references_error() } } impl<'tcx> ReferencesError for TraitPredicate<'tcx> { fn references_error(&self) -> bool { self.trait_ref.references_error() } } impl<'tcx> ReferencesError for ProjectionPredicate<'tcx> { fn references_error(&self) -> bool { self.projection_ty.trait_ref.references_error() || self.ty.references_error() } } impl<'tcx> ReferencesError for TraitRef<'tcx> { fn references_error(&self) -> bool { self.input_types().iter().any(|t| t.references_error()) } } impl<'tcx> ReferencesError for Ty<'tcx> { fn references_error(&self) -> bool { type_is_error(*self) } } impl<'tcx> ReferencesError for Predicate<'tcx> { fn references_error(&self) -> bool { match *self { Predicate::Trait(ref data) => data.references_error(), Predicate::Equate(ref data) => data.references_error(), Predicate::RegionOutlives(ref data) => data.references_error(), Predicate::TypeOutlives(ref data) => data.references_error(), Predicate::Projection(ref data) => data.references_error(), } } } impl ReferencesError for OutlivesPredicate where A : ReferencesError, B : ReferencesError { fn references_error(&self) -> bool { self.0.references_error() || self.1.references_error() } } impl<'tcx> ReferencesError for EquatePredicate<'tcx> { fn references_error(&self) -> bool { self.0.references_error() || self.1.references_error() } } impl ReferencesError for Region { fn references_error(&self) -> bool { false } } impl<'tcx> Repr<'tcx> for ClosureTy<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { format!("ClosureTy({},{},{},{},{},{})", self.unsafety, self.onceness, self.store, self.bounds.repr(tcx), self.sig.repr(tcx), self.abi) } } impl<'tcx> Repr<'tcx> for UnboxedClosureUpvar<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { format!("UnboxedClosureUpvar({},{})", self.def.repr(tcx), self.ty.repr(tcx)) } }