// ignore-tidy-filelength
-#![allow(usage_of_ty_tykind)]
-
pub use self::Variance::*;
pub use self::AssocItemContainer::*;
pub use self::BorrowKind::*;
use arena::SyncDroplessArena;
use crate::session::DataTypeKind;
-use serialize::{self, Encodable, Encoder};
+use rustc_serialize::{self, Encodable, Encoder};
use std::cell::RefCell;
use std::cmp::{self, Ordering};
use std::fmt;
use std::ops::Range;
use syntax::ast::{self, Name, Ident, NodeId};
use syntax::attr;
-use syntax::ext::hygiene::Mark;
+use syntax::ext::hygiene::ExpnId;
use syntax::symbol::{kw, sym, Symbol, LocalInternedString, InternedString};
use syntax_pos::Span;
pub enum AssocKind {
Const,
Method,
- Existential,
+ OpaqueTy,
Type
}
AssocKind::Const => DefKind::AssocConst,
AssocKind::Method => DefKind::Method,
AssocKind::Type => DefKind::AssocTy,
- AssocKind::Existential => DefKind::AssocExistential,
+ AssocKind::OpaqueTy => DefKind::AssocOpaqueTy,
}
}
/// for !
pub fn relevant_for_never(&self) -> bool {
match self.kind {
- AssocKind::Existential |
+ AssocKind::OpaqueTy |
AssocKind::Const |
AssocKind::Type => true,
// FIXME(canndrew): Be more thorough here, check if any argument is uninhabited.
tcx.fn_sig(self.def_id).skip_binder().to_string()
}
ty::AssocKind::Type => format!("type {};", self.ident),
- ty::AssocKind::Existential => format!("existential type {};", self.ident),
+ // FIXME(type_alias_impl_trait): we should print bounds here too.
+ ty::AssocKind::OpaqueTy => format!("type {};", self.ident),
ty::AssocKind::Const => {
format!("const {}: {:?};", self.ident, tcx.type_of(self.def_id))
}
}
}
+#[cfg_attr(not(bootstrap), allow(rustc::usage_of_ty_tykind))]
pub struct TyS<'tcx> {
pub sty: TyKind<'tcx>,
pub flags: TypeFlags,
impl<'tcx> TyS<'tcx> {
pub fn is_primitive_ty(&self) -> bool {
match self.sty {
- TyKind::Bool |
- TyKind::Char |
- TyKind::Int(_) |
- TyKind::Uint(_) |
- TyKind::Float(_) |
- TyKind::Infer(InferTy::IntVar(_)) |
- TyKind::Infer(InferTy::FloatVar(_)) |
- TyKind::Infer(InferTy::FreshIntTy(_)) |
- TyKind::Infer(InferTy::FreshFloatTy(_)) => true,
- TyKind::Ref(_, x, _) => x.is_primitive_ty(),
+ Bool |
+ Char |
+ Int(_) |
+ Uint(_) |
+ Float(_) |
+ Infer(InferTy::IntVar(_)) |
+ Infer(InferTy::FloatVar(_)) |
+ Infer(InferTy::FreshIntTy(_)) |
+ Infer(InferTy::FreshFloatTy(_)) => true,
+ Ref(_, x, _) => x.is_primitive_ty(),
_ => false,
}
}
pub fn is_suggestable(&self) -> bool {
match self.sty {
- TyKind::Opaque(..) |
- TyKind::FnDef(..) |
- TyKind::FnPtr(..) |
- TyKind::Dynamic(..) |
- TyKind::Closure(..) |
- TyKind::Infer(..) |
- TyKind::Projection(..) => false,
+ Opaque(..) |
+ FnDef(..) |
+ FnPtr(..) |
+ Dynamic(..) |
+ Closure(..) |
+ Infer(..) |
+ Projection(..) => false,
_ => true,
}
}
pub type Ty<'tcx> = &'tcx TyS<'tcx>;
-impl<'tcx> serialize::UseSpecializedEncodable for Ty<'tcx> {}
-impl<'tcx> serialize::UseSpecializedDecodable for Ty<'tcx> {}
+impl<'tcx> rustc_serialize::UseSpecializedEncodable for Ty<'tcx> {}
+impl<'tcx> rustc_serialize::UseSpecializedDecodable for Ty<'tcx> {}
pub type CanonicalTy<'tcx> = Canonical<'tcx, Ty<'tcx>>;
}
}
-impl<'tcx> serialize::UseSpecializedDecodable for &'tcx List<Ty<'tcx>> {}
+impl<'tcx> rustc_serialize::UseSpecializedDecodable for &'tcx List<Ty<'tcx>> {}
impl<T> List<T> {
#[inline(always)]
pub parent_count: usize,
pub params: Vec<GenericParamDef>,
- /// Reverse map to the `index` field of each `GenericParamDef`
+ /// Reverse map to the `index` field of each `GenericParamDef`.
#[stable_hasher(ignore)]
pub param_def_id_to_index: FxHashMap<DefId, u32>,
pub predicates: Vec<(Predicate<'tcx>, Span)>,
}
-impl<'tcx> serialize::UseSpecializedEncodable for GenericPredicates<'tcx> {}
-impl<'tcx> serialize::UseSpecializedDecodable for GenericPredicates<'tcx> {}
+impl<'tcx> rustc_serialize::UseSpecializedEncodable for GenericPredicates<'tcx> {}
+impl<'tcx> rustc_serialize::UseSpecializedDecodable for GenericPredicates<'tcx> {}
impl<'tcx> GenericPredicates<'tcx> {
pub fn instantiate(
impl<'tcx> PolyTraitPredicate<'tcx> {
pub fn def_id(&self) -> DefId {
- // Ok to skip binder since trait def-ID does not care about regions.
+ // Ok to skip binder since trait `DefId` does not care about regions.
self.skip_binder().def_id()
}
}
/// Note that this is not the `DefId` of the `TraitRef` containing this
/// associated type, which is in `tcx.associated_item(projection_def_id()).container`.
pub fn projection_def_id(&self) -> DefId {
- // Ok to skip binder since trait def-ID does not care about regions.
+ // Ok to skip binder since trait `DefId` does not care about regions.
self.skip_binder().projection_ty.item_def_id
}
}
/// particular point.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, HashStable)]
pub struct ParamEnv<'tcx> {
- /// Obligations that the caller must satisfy. This is basically
+ /// `Obligation`s that the caller must satisfy. This is basically
/// the set of bounds on the in-scope type parameters, translated
- /// into Obligations, and elaborated and normalized.
+ /// into `Obligation`s, and elaborated and normalized.
pub caller_bounds: &'tcx List<ty::Predicate<'tcx>>,
/// Typically, this is `Reveal::UserFacing`, but during codegen we
}
}
-impl<'tcx> serialize::UseSpecializedEncodable for &'tcx AdtDef {
+impl<'tcx> rustc_serialize::UseSpecializedEncodable for &'tcx AdtDef {
fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
self.did.encode(s)
}
}
-impl<'tcx> serialize::UseSpecializedDecodable for &'tcx AdtDef {}
+impl<'tcx> rustc_serialize::UseSpecializedDecodable for &'tcx AdtDef {}
impl<'a> HashStable<StableHashingContext<'a>> for AdtDef {
_ => false,
}
} else {
- match self.def_kind(def_id).expect("no def for def-id") {
+ match self.def_kind(def_id).expect("no def for `DefId`") {
DefKind::AssocConst
| DefKind::Method
| DefKind::AssocTy => true,
parent_vis: &hir::Visibility,
trait_item_ref: &hir::TraitItemRef)
-> AssocItem {
- let def_id = self.hir().local_def_id_from_hir_id(trait_item_ref.id.hir_id);
+ let def_id = self.hir().local_def_id(trait_item_ref.id.hir_id);
let (kind, has_self) = match trait_item_ref.kind {
hir::AssocItemKind::Const => (ty::AssocKind::Const, false),
hir::AssocItemKind::Method { has_self } => {
(ty::AssocKind::Method, has_self)
}
hir::AssocItemKind::Type => (ty::AssocKind::Type, false),
- hir::AssocItemKind::Existential => bug!("only impls can have existentials"),
+ hir::AssocItemKind::OpaqueTy => bug!("only impls can have opaque types"),
};
AssocItem {
parent_def_id: DefId,
impl_item_ref: &hir::ImplItemRef)
-> AssocItem {
- let def_id = self.hir().local_def_id_from_hir_id(impl_item_ref.id.hir_id);
+ let def_id = self.hir().local_def_id(impl_item_ref.id.hir_id);
let (kind, has_self) = match impl_item_ref.kind {
hir::AssocItemKind::Const => (ty::AssocKind::Const, false),
hir::AssocItemKind::Method { has_self } => {
(ty::AssocKind::Method, has_self)
}
hir::AssocItemKind::Type => (ty::AssocKind::Type, false),
- hir::AssocItemKind::Existential => (ty::AssocKind::Existential, false),
+ hir::AssocItemKind::OpaqueTy => (ty::AssocKind::OpaqueTy, false),
};
AssocItem {
self.expansion_that_defined(def_parent_def_id))
}
- fn expansion_that_defined(self, scope: DefId) -> Mark {
+ fn expansion_that_defined(self, scope: DefId) -> ExpnId {
match scope.krate {
LOCAL_CRATE => self.hir().definitions().expansion_that_defined(scope.index),
- _ => Mark::root(),
+ _ => ExpnId::root(),
}
}
fn associated_item(tcx: TyCtxt<'_>, def_id: DefId) -> AssocItem {
let id = tcx.hir().as_local_hir_id(def_id).unwrap();
let parent_id = tcx.hir().get_parent_item(id);
- let parent_def_id = tcx.hir().local_def_id_from_hir_id(parent_id);
+ let parent_def_id = tcx.hir().local_def_id(parent_id);
let parent_item = tcx.hir().expect_item(parent_id);
match parent_item.node {
hir::ItemKind::Impl(.., ref impl_item_refs) => {
tcx.arena.alloc_from_iter(
trait_item_refs.iter()
.map(|trait_item_ref| trait_item_ref.id)
- .map(|id| tcx.hir().local_def_id_from_hir_id(id.hir_id))
+ .map(|id| tcx.hir().local_def_id(id.hir_id))
)
}
hir::ItemKind::Impl(.., ref impl_item_refs) => {
tcx.arena.alloc_from_iter(
impl_item_refs.iter()
.map(|impl_item_ref| impl_item_ref.id)
- .map(|id| tcx.hir().local_def_id_from_hir_id(id.hir_id))
+ .map(|id| tcx.hir().local_def_id(id.hir_id))
)
}
hir::ItemKind::TraitAlias(..) => &[],
pub fn is_impl_trait_defn(tcx: TyCtxt<'_>, def_id: DefId) -> Option<DefId> {
if let Some(hir_id) = tcx.hir().as_local_hir_id(def_id) {
if let Node::Item(item) = tcx.hir().get(hir_id) {
- if let hir::ItemKind::Existential(ref exist_ty) = item.node {
- return exist_ty.impl_trait_fn;
+ if let hir::ItemKind::OpaqueTy(ref opaque_ty) = item.node {
+ return opaque_ty.impl_trait_fn;
}
}
}
projects / rust.git / blobdiff