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))
}
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,
(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 {
(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(),
}
}
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;
}
}
}