let bounds = bounds
.iter()
.filter_map(|bound| match *bound {
- Trait(ref ty, TraitBoundModifier::None) => {
+ GenericBound::Trait(ref ty, TraitBoundModifier::None) => {
Some(self.lower_poly_trait_ref(ty, itctx))
}
- Trait(_, TraitBoundModifier::Maybe) => None,
- Outlives(ref lifetime) => {
+ GenericBound::Trait(_, TraitBoundModifier::Maybe) => None,
+ GenericBound::Outlives(ref lifetime) => {
if lifetime_bound.is_none() {
lifetime_bound = Some(self.lower_lifetime(lifetime));
}
fn no_questions_in_bounds(&self, bounds: &GenericBounds, where_: &str, is_trait: bool) {
for bound in bounds {
- if let Trait(ref poly, TraitBoundModifier::Maybe) = *bound {
+ if let GenericBound::Trait(ref poly, TraitBoundModifier::Maybe) = *bound {
let mut err = self.err_handler().struct_span_err(poly.span,
&format!("`?Trait` is not permitted in {}", where_));
if is_trait {
TyKind::TraitObject(ref bounds, ..) => {
let mut any_lifetime_bounds = false;
for bound in bounds {
- if let Outlives(ref lifetime) = *bound {
+ if let GenericBound::Outlives(ref lifetime) = *bound {
if any_lifetime_bounds {
span_err!(self.session, lifetime.ident.span, E0226,
"only a single explicit lifetime bound is permitted");
}
TyKind::ImplTrait(ref bounds) => {
if !bounds.iter()
- .any(|b| if let Trait(..) = *b { true } else { false }) {
+ .any(|b| if let GenericBound::Trait(..) = *b { true } else { false }) {
self.err_handler().span_err(ty.span, "at least one trait must be specified");
}
}
// super-traits
for super_bound in trait_refs.iter() {
let trait_ref = match *super_bound {
- ast::Trait(ref trait_ref, _) => trait_ref,
- ast::Outlives(..) => {
- continue;
- }
+ ast::GenericBound::Trait(ref trait_ref, _) => trait_ref,
+ ast::GenericBound::Outlives(..) => continue,
};
let trait_ref = &trait_ref.trait_ref;
ast::GenericParamKind::Lifetime { .. } => {}
ast::GenericParamKind::Type { ref default, .. } => {
for bound in ¶m.bounds {
- if let ast::Trait(ref trait_ref, _) = *bound {
+ if let ast::GenericBound::Trait(ref trait_ref, _) = *bound {
self.process_path(trait_ref.trait_ref.ref_id, &trait_ref.trait_ref.path)
}
}
let polarity = tcx.impl_polarity(did);
let trait_ = associated_trait.clean(cx).map(|bound| {
match bound {
- clean::TraitBound(polyt, _) => polyt.trait_,
- clean::Outlives(..) => unreachable!(),
+ clean::GenericBound::TraitBound(polyt, _) => polyt.trait_,
+ clean::GenericBound::Outlives(..) => unreachable!(),
}
});
if trait_.def_id() == tcx.lang_items().deref_trait() {
let provided = trait_.def_id().map(|did| {
tcx.provided_trait_methods(did)
- .into_iter()
- .map(|meth| meth.name.to_string())
- .collect()
+ .into_iter()
+ .map(|meth| meth.name.to_string())
+ .collect()
}).unwrap_or(FxHashSet());
ret.push(clean::Item {
pub use self::Type::*;
pub use self::Mutability::*;
pub use self::ItemEnum::*;
-pub use self::GenericBound::*;
pub use self::SelfTy::*;
pub use self::FunctionRetTy::*;
pub use self::Visibility::{Public, Inherited};
let path = external_path(cx, &cx.tcx.item_name(did).as_str(),
Some(did), false, vec![], empty);
inline::record_extern_fqn(cx, did, TypeKind::Trait);
- TraitBound(PolyTrait {
+ GenericBound::TraitBound(PolyTrait {
trait_: ResolvedPath {
path,
typarams: None,
impl Clean<GenericBound> for hir::GenericBound {
fn clean(&self, cx: &DocContext) -> GenericBound {
match *self {
- hir::GenericBound::Outlives(lt) => Outlives(lt.clean(cx)),
- hir::GenericBound::Trait(ref t, modifier) => TraitBound(t.clean(cx), modifier),
+ hir::GenericBound::Outlives(lt) => GenericBound::Outlives(lt.clean(cx)),
+ hir::GenericBound::Trait(ref t, modifier) => {
+ GenericBound::TraitBound(t.clean(cx), modifier)
+ }
}
}
}
}
}
- TraitBound(
+ GenericBound::TraitBound(
PolyTrait {
trait_: ResolvedPath {
path,
impl<'tcx> Clean<Option<Vec<GenericBound>>> for Substs<'tcx> {
fn clean(&self, cx: &DocContext) -> Option<Vec<GenericBound>> {
let mut v = Vec::new();
- v.extend(self.regions().filter_map(|r| r.clean(cx))
- .map(GenericBound::Outlives));
- v.extend(self.types().map(|t| TraitBound(PolyTrait {
+ v.extend(self.regions().filter_map(|r| r.clean(cx)).map(GenericBound::Outlives));
+ v.extend(self.types().map(|t| GenericBound::TraitBound(PolyTrait {
trait_: t.clean(cx),
generic_params: Vec::new(),
}, hir::TraitBoundModifier::None)));
match bounds[0].clean(cx).trait_ {
ResolvedPath { path, typarams: None, did, is_generic } => {
let mut bounds: Vec<self::GenericBound> = bounds[1..].iter().map(|bound| {
- TraitBound(bound.clean(cx), hir::TraitBoundModifier::None)
+ self::GenericBound::TraitBound(bound.clean(cx),
+ hir::TraitBoundModifier::None)
}).collect();
if !lifetime.is_elided() {
- bounds.push(self::Outlives(lifetime.clean(cx)));
+ bounds.push(self::GenericBound::Outlives(lifetime.clean(cx)));
}
ResolvedPath { path, typarams: Some(bounds), did, is_generic, }
}
let path = external_path(cx, &cx.tcx.item_name(did).as_str(),
Some(did), false, vec![], empty);
inline::record_extern_fqn(cx, did, TypeKind::Trait);
- let bound = TraitBound(PolyTrait {
+ let bound = GenericBound::TraitBound(PolyTrait {
trait_: ResolvedPath {
path,
typarams: None,
};
!bounds.iter_mut().any(|b| {
let trait_ref = match *b {
- clean::TraitBound(ref mut tr, _) => tr,
- clean::Outlives(..) => return false,
+ clean::GenericBound::TraitBound(ref mut tr, _) => tr,
+ clean::GenericBound::Outlives(..) => return false,
};
let (did, path) = match trait_ref.trait_ {
clean::ResolvedPath { did, ref mut path, ..} => (did, path),
impl fmt::Display for clean::GenericBound {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
- clean::Outlives(ref lt) => {
+ clean::GenericBound::Outlives(ref lt) => {
write!(f, "{}", *lt)
}
- clean::TraitBound(ref ty, modifier) => {
+ clean::GenericBound::TraitBound(ref ty, modifier) => {
let modifier_str = match modifier {
hir::TraitBoundModifier::None => "",
hir::TraitBoundModifier::Maybe => "?",
// The Rust abstract syntax tree.
-pub use self::GenericBound::*;
pub use self::UnsafeSource::*;
pub use self::GenericArgs::*;
pub use symbol::{Ident, Symbol as Name};
impl GenericBound {
pub fn span(&self) -> Span {
match self {
- &Trait(ref t, ..) => t.span,
- &Outlives(ref l) => l.ident.span,
+ &GenericBound::Trait(ref t, ..) => t.span,
+ &GenericBound::Outlives(ref l) => l.ident.span,
}
}
}
fn to_bound(&self) -> Option<GenericBound> {
match &self.node {
ExprKind::Path(None, path) =>
- Some(Trait(PolyTraitRef::new(Vec::new(), path.clone(), self.span),
- TraitBoundModifier::None)),
+ Some(GenericBound::Trait(PolyTraitRef::new(Vec::new(), path.clone(), self.span),
+ TraitBoundModifier::None)),
_ => None,
}
}
}
fn ty_param_bound(&self, path: ast::Path) -> ast::GenericBound {
- ast::Trait(self.poly_trait_ref(path.span, path), ast::TraitBoundModifier::None)
+ ast::GenericBound::Trait(self.poly_trait_ref(path.span, path),
+ ast::TraitBoundModifier::None)
}
fn lifetime(&self, span: Span, ident: ast::Ident) -> ast::Lifetime {
pub fn noop_fold_param_bound<T>(pb: GenericBound, fld: &mut T) -> GenericBound where T: Folder {
match pb {
- Trait(ty, modifier) => {
- Trait(fld.fold_poly_trait_ref(ty), modifier)
+ GenericBound::Trait(ty, modifier) => {
+ GenericBound::Trait(fld.fold_poly_trait_ref(ty), modifier)
+ }
+ GenericBound::Outlives(lifetime) => {
+ GenericBound::Outlives(noop_fold_lifetime(lifetime, fld))
}
- Outlives(lifetime) => Outlives(noop_fold_lifetime(lifetime, fld)),
}
}
use rustc_target::spec::abi::{self, Abi};
use ast::{AngleBracketedArgs, ParenthesizedArgData, AttrStyle, BareFnTy};
-use ast::{Outlives, Trait, TraitBoundModifier};
+use ast::{GenericBound, TraitBoundModifier};
use ast::Unsafety;
use ast::{Mod, AnonConst, Arg, Arm, Attribute, BindingMode, TraitItemKind};
use ast::Block;
TyKind::TraitObject(ref bounds, TraitObjectSyntax::None)
if maybe_bounds && bounds.len() == 1 && !trailing_plus => {
let path = match bounds[0] {
- Trait(ref pt, ..) => pt.trait_ref.path.clone(),
+ GenericBound::Trait(ref pt, ..) => pt.trait_ref.path.clone(),
_ => self.bug("unexpected lifetime bound"),
};
self.parse_remaining_bounds(Vec::new(), path, lo, true)?
fn parse_remaining_bounds(&mut self, generic_params: Vec<GenericParam>, path: ast::Path,
lo: Span, parse_plus: bool) -> PResult<'a, TyKind> {
let poly_trait_ref = PolyTraitRef::new(generic_params, path, lo.to(self.prev_span));
- let mut bounds = vec![Trait(poly_trait_ref, TraitBoundModifier::None)];
+ let mut bounds = vec![GenericBound::Trait(poly_trait_ref, TraitBoundModifier::None)];
if parse_plus {
self.eat_plus(); // `+`, or `+=` gets split and `+` is discarded
bounds.append(&mut self.parse_ty_param_bounds()?);
self.span_err(question_span,
"`?` may only modify trait bounds, not lifetime bounds");
}
- bounds.push(Outlives(self.expect_lifetime()));
+ bounds.push(GenericBound::Outlives(self.expect_lifetime()));
if has_parens {
self.expect(&token::CloseDelim(token::Paren))?;
self.span_err(self.prev_span,
} else {
TraitBoundModifier::None
};
- bounds.push(Trait(poly_trait, modifier));
+ bounds.push(GenericBound::Trait(poly_trait, modifier));
}
} else {
break
use rustc_target::spec::abi::{self, Abi};
use ast::{self, BlockCheckMode, PatKind, RangeEnd, RangeSyntax};
-use ast::{SelfKind, Outlives, Trait, TraitBoundModifier};
+use ast::{SelfKind, GenericBound, TraitBoundModifier};
use ast::{Attribute, MacDelimiter, GenericArg};
use util::parser::{self, AssocOp, Fixity};
use attr;
self.print_generic_params(&generics.params)?;
let mut real_bounds = Vec::with_capacity(bounds.len());
for b in bounds.iter() {
- if let Trait(ref ptr, ast::TraitBoundModifier::Maybe) = *b {
+ if let GenericBound::Trait(ref ptr, ast::TraitBoundModifier::Maybe) = *b {
self.s.space()?;
self.word_space("for ?")?;
self.print_trait_ref(&ptr.trait_ref)?;
let mut real_bounds = Vec::with_capacity(bounds.len());
// FIXME(durka) this seems to be some quite outdated syntax
for b in bounds.iter() {
- if let Trait(ref ptr, ast::TraitBoundModifier::Maybe) = *b {
+ if let GenericBound::Trait(ref ptr, ast::TraitBoundModifier::Maybe) = *b {
self.s.space()?;
self.word_space("for ?")?;
self.print_trait_ref(&ptr.trait_ref)?;
}
match bound {
- Trait(tref, modifier) => {
+ GenericBound::Trait(tref, modifier) => {
if modifier == &TraitBoundModifier::Maybe {
self.s.word("?")?;
}
self.print_poly_trait_ref(tref)?;
}
- Outlives(lt) => self.print_lifetime(*lt)?,
+ GenericBound::Outlives(lt) => self.print_lifetime(*lt)?,
}
}
}
pub fn walk_param_bound<'a, V: Visitor<'a>>(visitor: &mut V, bound: &'a GenericBound) {
match *bound {
- Trait(ref typ, ref modifier) => {
- visitor.visit_poly_trait_ref(typ, modifier);
- }
- Outlives(ref lifetime) => {
- visitor.visit_lifetime(lifetime);
- }
+ GenericBound::Trait(ref typ, ref modifier) => visitor.visit_poly_trait_ref(typ, modifier),
+ GenericBound::Outlives(ref lifetime) => visitor.visit_lifetime(lifetime),
}
}