From 95f1866a4df85e815886901a7b64d8dd64709872 Mon Sep 17 00:00:00 2001 From: varkor Date: Thu, 14 Jun 2018 12:23:46 +0100 Subject: [PATCH] Make GenericBound explicit --- src/librustc/hir/lowering.rs | 6 +++--- src/librustc_passes/ast_validation.rs | 6 +++--- src/librustc_save_analysis/dump_visitor.rs | 8 +++----- src/librustdoc/clean/inline.rs | 10 +++++----- src/librustdoc/clean/mod.rs | 23 +++++++++++----------- src/librustdoc/clean/simplify.rs | 4 ++-- src/librustdoc/html/format.rs | 4 ++-- src/libsyntax/ast.rs | 9 ++++----- src/libsyntax/ext/build.rs | 3 ++- src/libsyntax/fold.rs | 8 +++++--- src/libsyntax/parse/parser.rs | 10 +++++----- src/libsyntax/print/pprust.rs | 10 +++++----- src/libsyntax/visit.rs | 8 ++------ 13 files changed, 53 insertions(+), 56 deletions(-) diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index b725432eb5c..7628504ba0d 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -1109,11 +1109,11 @@ fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext) -> P { 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)); } diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs index 4f04ad89698..fc54d323b0f 100644 --- a/src/librustc_passes/ast_validation.rs +++ b/src/librustc_passes/ast_validation.rs @@ -101,7 +101,7 @@ fn check_trait_fn_not_const(&self, constness: Spanned) { 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 { @@ -190,7 +190,7 @@ fn visit_ty(&mut self, ty: &'a Ty) { 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"); @@ -203,7 +203,7 @@ fn visit_ty(&mut self, ty: &'a Ty) { } 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"); } } diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs index 0f0f3f6e789..7da5b1668b3 100644 --- a/src/librustc_save_analysis/dump_visitor.rs +++ b/src/librustc_save_analysis/dump_visitor.rs @@ -761,10 +761,8 @@ fn process_trait( // 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; @@ -1489,7 +1487,7 @@ fn visit_generics(&mut self, generics: &'l ast::Generics) { 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) } } diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index f3a833bad8f..114cb0e455d 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -374,8 +374,8 @@ pub fn build_impl(cx: &DocContext, did: DefId, ret: &mut Vec) { 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() { @@ -387,9 +387,9 @@ pub fn build_impl(cx: &DocContext, did: DefId, ret: &mut Vec) { 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 { diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 031a948fe80..0979c3d8558 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -14,7 +14,6 @@ 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}; @@ -1470,7 +1469,7 @@ fn maybe_sized(cx: &DocContext) -> GenericBound { 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, @@ -1510,8 +1509,10 @@ fn get_trait_type(&self) -> Option { impl Clean 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) + } } } } @@ -1599,7 +1600,7 @@ fn clean(&self, cx: &DocContext) -> GenericBound { } } - TraitBound( + GenericBound::TraitBound( PolyTrait { trait_: ResolvedPath { path, @@ -1623,9 +1624,8 @@ fn clean(&self, cx: &DocContext) -> GenericBound { impl<'tcx> Clean>> for Substs<'tcx> { fn clean(&self, cx: &DocContext) -> Option> { 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))); @@ -2978,10 +2978,11 @@ fn clean(&self, cx: &DocContext) -> Type { match bounds[0].clean(cx).trait_ { ResolvedPath { path, typarams: None, did, is_generic } => { let mut bounds: Vec = 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, } } @@ -3086,7 +3087,7 @@ fn clean(&self, cx: &DocContext) -> Type { 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, diff --git a/src/librustdoc/clean/simplify.rs b/src/librustdoc/clean/simplify.rs index a54eb64443b..30a55bf0d18 100644 --- a/src/librustdoc/clean/simplify.rs +++ b/src/librustdoc/clean/simplify.rs @@ -83,8 +83,8 @@ pub fn where_clauses(cx: &DocContext, clauses: Vec) -> Vec { }; !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), diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 987821d2e30..3d360f2f344 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -270,10 +270,10 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 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 => "?", diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 9dc13fab2d6..76d19ce0ac5 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -10,7 +10,6 @@ // The Rust abstract syntax tree. -pub use self::GenericBound::*; pub use self::UnsafeSource::*; pub use self::GenericArgs::*; pub use symbol::{Ident, Symbol as Name}; @@ -290,8 +289,8 @@ pub enum GenericBound { 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, } } } @@ -930,8 +929,8 @@ pub fn returns(&self) -> bool { fn to_bound(&self) -> Option { 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, } } diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 9de6e14fbeb..40d45306149 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -465,7 +465,8 @@ fn poly_trait_ref(&self, span: Span, path: ast::Path) -> ast::PolyTraitRef { } 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 { diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 5db5d0781ea..03668cc279a 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -678,10 +678,12 @@ pub fn noop_fold_fn_decl(decl: P, fld: &mut T) -> P { pub fn noop_fold_param_bound(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)), } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 8588f4c492f..675849c8a5c 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -10,7 +10,7 @@ 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; @@ -1444,7 +1444,7 @@ fn parse_ty_common(&mut self, allow_plus: bool, allow_qpath_recovery: bool) 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)? @@ -1566,7 +1566,7 @@ fn parse_ty_common(&mut self, allow_plus: bool, allow_qpath_recovery: bool) fn parse_remaining_bounds(&mut self, generic_params: Vec, 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()?); @@ -4752,7 +4752,7 @@ fn parse_ty_param_bounds_common(&mut self, allow_plus: bool) -> PResult<'a, Gene 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, @@ -4770,7 +4770,7 @@ fn parse_ty_param_bounds_common(&mut self, allow_plus: bool) -> PResult<'a, Gene } else { TraitBoundModifier::None }; - bounds.push(Trait(poly_trait, modifier)); + bounds.push(GenericBound::Trait(poly_trait, modifier)); } } else { break diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 1e0b107ef6e..7a55919f422 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -12,7 +12,7 @@ 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; @@ -1364,7 +1364,7 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> { 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)?; @@ -1390,7 +1390,7 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> { 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)?; @@ -2826,13 +2826,13 @@ pub fn print_type_bounds(&mut self, } 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)?, } } } diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 71b606f08a5..5476a3f0d2a 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -481,12 +481,8 @@ pub fn walk_global_asm<'a, V: Visitor<'a>>(_: &mut V, _: &'a GlobalAsm) { 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), } } -- GitLab