diff options
| author | bors <bors@rust-lang.org> | 2019-12-23 02:47:52 +0000 |
|---|---|---|
| committer | bors <bors@rust-lang.org> | 2019-12-23 02:47:52 +0000 |
| commit | a916ac22b9f7f1f0f7aba0a41a789b3ecd765018 (patch) | |
| tree | 139cba4184f0f290fdbdff1aa0aa68352b16ccbb /src/libsyntax | |
| parent | 9b98af84c4aa66392236fff59c86da2130d46d46 (diff) | |
| parent | 0f24ccd21d9f734a21daaf3566900127167556d1 (diff) | |
| download | rust-a916ac22b9f7f1f0f7aba0a41a789b3ecd765018.tar.gz rust-a916ac22b9f7f1f0f7aba0a41a789b3ecd765018.zip | |
Auto merge of #67540 - Mark-Simulacrum:fmt-the-world, r=Centril
Format the world This PR modifies the formatting infrastructure a bit in the first commit (to enable the forgotten 2018 edition), as well as removes most directories from the ignore list in rustfmt.toml. It then follows that up with the second commit which runs `x.py fmt` and formats the entire repository. We continue to not format the test directory (`src/test`) because of interactions with pretty printing and, in part, because re-blessing all of those files is somewhat harder to review, so is best suited for a follow up PR in my opinion.
Diffstat (limited to 'src/libsyntax')
28 files changed, 1740 insertions, 1631 deletions
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index aa38a8135ce..9009faa5440 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -18,16 +18,16 @@ //! - [`Attribute`]: Metadata associated with item. //! - [`UnOp`], [`UnOpKind`], [`BinOp`], [`BinOpKind`]: Unary and binary operators. +pub use crate::util::parser::ExprPrecedence; pub use GenericArgs::*; pub use UnsafeSource::*; -pub use crate::util::parser::ExprPrecedence; pub use syntax_pos::symbol::{Ident, Symbol as Name}; use crate::ptr::P; use crate::source_map::{dummy_spanned, respan, Spanned}; use crate::token::{self, DelimToken}; -use crate::tokenstream::{TokenStream, TokenTree, DelimSpan}; +use crate::tokenstream::{DelimSpan, TokenStream, TokenTree}; use syntax_pos::symbol::{kw, sym, Symbol}; use syntax_pos::{Span, DUMMY_SP}; @@ -36,11 +36,11 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::sync::Lrc; use rustc_data_structures::thin_vec::ThinVec; use rustc_index::vec::Idx; -use rustc_serialize::{self, Decoder, Encoder}; use rustc_macros::HashStable_Generic; +use rustc_serialize::{self, Decoder, Encoder}; -use std::iter; use std::fmt; +use std::iter; #[cfg(test)] mod tests; @@ -76,12 +76,7 @@ pub struct Lifetime { impl fmt::Debug for Lifetime { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!( - f, - "lifetime({}: {})", - self.id, - self - ) + write!(f, "lifetime({}: {})", self.id, self) } } @@ -107,9 +102,7 @@ pub struct Path { impl PartialEq<Symbol> for Path { fn eq(&self, symbol: &Symbol) -> bool { - self.segments.len() == 1 && { - self.segments[0].ident.name == *symbol - } + self.segments.len() == 1 && { self.segments[0].ident.name == *symbol } } } @@ -126,10 +119,7 @@ impl Path { // Convert a span and an identifier to the corresponding // one-segment path. pub fn from_ident(ident: Ident) -> Path { - Path { - segments: vec![PathSegment::from_ident(ident)], - span: ident.span, - } + Path { segments: vec![PathSegment::from_ident(ident)], span: ident.span } } pub fn is_global(&self) -> bool { @@ -330,8 +320,12 @@ impl fmt::Display for ParamKindOrd { pub enum GenericParamKind { /// A lifetime definition (e.g., `'a: 'b + 'c + 'd`). Lifetime, - Type { default: Option<P<Ty>> }, - Const { ty: P<Ty> }, + Type { + default: Option<P<Ty>>, + }, + Const { + ty: P<Ty>, + }, } #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] @@ -358,10 +352,7 @@ impl Default for Generics { fn default() -> Generics { Generics { params: Vec::new(), - where_clause: WhereClause { - predicates: Vec::new(), - span: DUMMY_SP, - }, + where_clause: WhereClause { predicates: Vec::new(), span: DUMMY_SP }, span: DUMMY_SP, } } @@ -515,9 +506,9 @@ impl Pat { PatKind::Path(qself, path) => TyKind::Path(qself.clone(), path.clone()), PatKind::Mac(mac) => TyKind::Mac(mac.clone()), // `&mut? P` can be reinterpreted as `&mut? T` where `T` is `P` reparsed as a type. - PatKind::Ref(pat, mutbl) => pat - .to_ty() - .map(|ty| TyKind::Rptr(None, MutTy { ty, mutbl: *mutbl }))?, + PatKind::Ref(pat, mutbl) => { + pat.to_ty().map(|ty| TyKind::Rptr(None, MutTy { ty, mutbl: *mutbl }))? + } // A slice/array pattern `[P]` can be reparsed as `[T]`, an unsized array, // when `P` can be reparsed as a type `T`. PatKind::Slice(pats) if pats.len() == 1 => pats[0].to_ty().map(TyKind::Slice)?, @@ -534,11 +525,7 @@ impl Pat { _ => return None, }; - Some(P(Ty { - kind, - id: self.id, - span: self.span, - })) + Some(P(Ty { kind, id: self.id, span: self.span })) } /// Walk top-down and call `it` in each place where a pattern occurs @@ -557,15 +544,12 @@ impl Pat { PatKind::Struct(_, fields, _) => fields.iter().for_each(|field| field.pat.walk(it)), // Sequence of patterns. - PatKind::TupleStruct(_, s) - | PatKind::Tuple(s) - | PatKind::Slice(s) - | PatKind::Or(s) => s.iter().for_each(|p| p.walk(it)), + PatKind::TupleStruct(_, s) | PatKind::Tuple(s) | PatKind::Slice(s) | PatKind::Or(s) => { + s.iter().for_each(|p| p.walk(it)) + } // Trivial wrappers over inner patterns. - PatKind::Box(s) - | PatKind::Ref(s, _) - | PatKind::Paren(s) => s.walk(it), + PatKind::Box(s) | PatKind::Ref(s, _) | PatKind::Paren(s) => s.walk(it), // These patterns do not contain subpatterns, skip. PatKind::Wild @@ -574,7 +558,7 @@ impl Pat { | PatKind::Range(..) | PatKind::Ident(..) | PatKind::Path(..) - | PatKind::Mac(_) => {}, + | PatKind::Mac(_) => {} } } @@ -692,8 +676,19 @@ pub enum PatKind { Mac(Mac), } -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, - RustcEncodable, RustcDecodable, Debug, Copy, HashStable_Generic)] +#[derive( + Clone, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + RustcEncodable, + RustcDecodable, + Debug, + Copy, + HashStable_Generic +)] pub enum Mutability { Mut, Not, @@ -1055,9 +1050,9 @@ impl Expr { ExprKind::Paren(expr) => expr.to_ty().map(TyKind::Paren)?, - ExprKind::AddrOf(BorrowKind::Ref, mutbl, expr) => expr - .to_ty() - .map(|ty| TyKind::Rptr(None, MutTy { ty, mutbl: *mutbl }))?, + ExprKind::AddrOf(BorrowKind::Ref, mutbl, expr) => { + expr.to_ty().map(|ty| TyKind::Rptr(None, MutTy { ty, mutbl: *mutbl }))? + } ExprKind::Repeat(expr, expr_len) => { expr.to_ty().map(|ty| TyKind::Array(ty, expr_len.clone()))? @@ -1066,10 +1061,7 @@ impl Expr { ExprKind::Array(exprs) if exprs.len() == 1 => exprs[0].to_ty().map(TyKind::Slice)?, ExprKind::Tup(exprs) => { - let tys = exprs - .iter() - .map(|expr| expr.to_ty()) - .collect::<Option<Vec<_>>>()?; + let tys = exprs.iter().map(|expr| expr.to_ty()).collect::<Option<Vec<_>>>()?; TyKind::Tup(tys) } @@ -1088,11 +1080,7 @@ impl Expr { _ => return None, }; - Some(P(Ty { - kind, - id: self.id, - span: self.span, - })) + Some(P(Ty { kind, id: self.id, span: self.span })) } pub fn precedence(&self) -> ExprPrecedence { @@ -1322,8 +1310,19 @@ pub enum CaptureBy { /// The movability of a generator / closure literal: /// whether a generator contains self-references, causing it to be `!Unpin`. -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, - RustcEncodable, RustcDecodable, Debug, Copy, HashStable_Generic)] +#[derive( + Clone, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + RustcEncodable, + RustcDecodable, + Debug, + Copy, + HashStable_Generic +)] pub enum Movability { /// May contain self-references, `!Unpin`. Static, @@ -1383,8 +1382,7 @@ impl MacArgs { pub fn inner_tokens(&self) -> TokenStream { match self { MacArgs::Empty => TokenStream::default(), - MacArgs::Delimited(.., tokens) | - MacArgs::Eq(.., tokens) => tokens.clone(), + MacArgs::Delimited(.., tokens) | MacArgs::Eq(.., tokens) => tokens.clone(), } } @@ -1393,17 +1391,19 @@ impl MacArgs { pub fn outer_tokens(&self) -> TokenStream { match *self { MacArgs::Empty => TokenStream::default(), - MacArgs::Delimited(dspan, delim, ref tokens) => - TokenTree::Delimited(dspan, delim.to_token(), tokens.clone()).into(), - MacArgs::Eq(eq_span, ref tokens) => iter::once(TokenTree::token(token::Eq, eq_span)) - .chain(tokens.trees()).collect(), + MacArgs::Delimited(dspan, delim, ref tokens) => { + TokenTree::Delimited(dspan, delim.to_token(), tokens.clone()).into() + } + MacArgs::Eq(eq_span, ref tokens) => { + iter::once(TokenTree::token(token::Eq, eq_span)).chain(tokens.trees()).collect() + } } } /// Whether a macro with these arguments needs a semicolon /// when used as a standalone item or statement. pub fn need_semicolon(&self) -> bool { - !matches!(self, MacArgs::Delimited(_, MacDelimiter::Brace ,_)) + !matches!(self, MacArgs::Delimited(_, MacDelimiter::Brace, _)) } } @@ -1628,7 +1628,7 @@ pub struct AssocItem { /// The `Option`s below denote the bodies, where `Some(_)` /// means "provided" and conversely `None` means "required". #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] -pub enum AssocItemKind { +pub enum AssocItemKind { /// An associated constant, `const $ident: $ty $def?;` where `def ::= "=" $expr? ;`. /// If `def` is parsed, then the associated constant is provided, and otherwise required. Const(P<Ty>, Option<P<Expr>>), @@ -1643,8 +1643,19 @@ pub enum AssocItemKind { Macro(Mac), } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, HashStable_Generic, - RustcEncodable, RustcDecodable, Debug)] +#[derive( + Clone, + Copy, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + HashStable_Generic, + RustcEncodable, + RustcDecodable, + Debug +)] pub enum FloatTy { F32, F64, @@ -1673,8 +1684,19 @@ impl FloatTy { } } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, HashStable_Generic, - RustcEncodable, RustcDecodable, Debug)] +#[derive( + Clone, + Copy, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + HashStable_Generic, + RustcEncodable, + RustcDecodable, + Debug +)] pub enum IntTy { Isize, I8, @@ -1738,8 +1760,19 @@ impl IntTy { } } -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, HashStable_Generic, - RustcEncodable, RustcDecodable, Copy, Debug)] +#[derive( + Clone, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + HashStable_Generic, + RustcEncodable, + RustcDecodable, + Copy, + Debug +)] pub enum UintTy { Usize, U8, @@ -1814,13 +1847,9 @@ pub struct AssocTyConstraint { #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum AssocTyConstraintKind { /// E.g., `A = Bar` in `Foo<A = Bar>`. - Equality { - ty: P<Ty>, - }, + Equality { ty: P<Ty> }, /// E.g. `A: TraitA + TraitB` in `Foo<A: TraitA + TraitB>`. - Bound { - bounds: GenericBounds, - }, + Bound { bounds: GenericBounds }, } #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] @@ -1889,19 +1918,11 @@ pub enum TyKind { impl TyKind { pub fn is_implicit_self(&self) -> bool { - if let TyKind::ImplicitSelf = *self { - true - } else { - false - } + if let TyKind::ImplicitSelf = *self { true } else { false } } pub fn is_unit(&self) -> bool { - if let TyKind::Tup(ref tys) = *self { - tys.is_empty() - } else { - false - } + if let TyKind::Tup(ref tys) = *self { tys.is_empty() } else { false } } /// HACK(type_alias_impl_trait, Centril): A temporary crutch used @@ -2016,11 +2037,7 @@ impl Param { /// Builds a `Param` object from `ExplicitSelf`. pub fn from_self(attrs: AttrVec, eself: ExplicitSelf, eself_ident: Ident) -> Param { let span = eself.span.to(eself_ident.span); - let infer_ty = P(Ty { - id: DUMMY_NODE_ID, - kind: TyKind::ImplicitSelf, - span, - }); + let infer_ty = P(Ty { id: DUMMY_NODE_ID, kind: TyKind::ImplicitSelf, span }); let param = |mutbl, ty| Param { attrs, pat: P(Pat { @@ -2031,7 +2048,7 @@ impl Param { span, ty, id: DUMMY_NODE_ID, - is_placeholder: false + is_placeholder: false, }; match eself.node { SelfKind::Explicit(ty, mutbl) => param(mutbl, ty), @@ -2040,13 +2057,7 @@ impl Param { Mutability::Not, P(Ty { id: DUMMY_NODE_ID, - kind: TyKind::Rptr( - lt, - MutTy { - ty: infer_ty, - mutbl, - }, - ), + kind: TyKind::Rptr(lt, MutTy { ty: infer_ty, mutbl }), span, }), ), @@ -2088,8 +2099,19 @@ pub enum IsAuto { No, } -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, - RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive( + Copy, + Clone, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + RustcEncodable, + RustcDecodable, + Debug, + HashStable_Generic +)] pub enum Unsafety { Unsafe, Normal, @@ -2118,29 +2140,19 @@ impl fmt::Display for Unsafety { #[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug)] pub enum IsAsync { - Async { - closure_id: NodeId, - return_impl_trait_id: NodeId, - }, + Async { closure_id: NodeId, return_impl_trait_id: NodeId }, NotAsync, } impl IsAsync { pub fn is_async(self) -> bool { - if let IsAsync::Async { .. } = self { - true - } else { - false - } + if let IsAsync::Async { .. } = self { true } else { false } } /// In ths case this is an `async` return, the `NodeId` for the generated `impl Trait` item. pub fn opt_return_id(self) -> Option<NodeId> { match self { - IsAsync::Async { - return_impl_trait_id, - .. - } => Some(return_impl_trait_id), + IsAsync::Async { return_impl_trait_id, .. } => Some(return_impl_trait_id), IsAsync::NotAsync => None, } } @@ -2178,7 +2190,8 @@ impl fmt::Debug for ImplPolarity { } #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] -pub enum FunctionRetTy { // FIXME(Centril): Rename to `FnRetTy` and in HIR also. +pub enum FunctionRetTy { + // FIXME(Centril): Rename to `FnRetTy` and in HIR also. /// Returns type is not specified. /// /// Functions default to `()` and closures default to inference. @@ -2282,11 +2295,7 @@ impl UseTree { match self.kind { UseTreeKind::Simple(Some(rename), ..) => rename, UseTreeKind::Simple(None, ..) => { - self.prefix - .segments - .last() - .expect("empty prefix in a simple import") - .ident + self.prefix.segments.last().expect("empty prefix in a simple import").ident } _ => panic!("`UseTree::ident` can only be used on a simple import"), } @@ -2388,10 +2397,7 @@ impl PolyTraitRef { pub fn new(generic_params: Vec<GenericParam>, path: Path, span: Span) -> Self { PolyTraitRef { bound_generic_params: generic_params, - trait_ref: TraitRef { - path, - ref_id: DUMMY_NODE_ID, - }, + trait_ref: TraitRef { path, ref_id: DUMMY_NODE_ID }, span, } } @@ -2418,11 +2424,7 @@ pub enum VisibilityKind { impl VisibilityKind { pub fn is_pub(&self) -> bool { - if let VisibilityKind::Public = *self { - true - } else { - false - } + if let VisibilityKind::Public = *self { true } else { false } } } diff --git a/src/libsyntax/attr/builtin.rs b/src/libsyntax/attr/builtin.rs index d780d0ad764..65b67981474 100644 --- a/src/libsyntax/attr/builtin.rs +++ b/src/libsyntax/attr/builtin.rs @@ -7,11 +7,11 @@ use crate::print::pprust; use crate::sess::ParseSess; use errors::{Applicability, Handler}; +use rustc_feature::{find_gated_cfg, is_builtin_attr_name, Features, GatedCfg}; +use rustc_macros::HashStable_Generic; use std::num::NonZeroU32; use syntax_pos::hygiene::Transparency; -use syntax_pos::{symbol::Symbol, symbol::sym, Span}; -use rustc_feature::{Features, find_gated_cfg, GatedCfg, is_builtin_attr_name}; -use rustc_macros::HashStable_Generic; +use syntax_pos::{symbol::sym, symbol::Symbol, Span}; use rustc_error_codes::*; @@ -31,25 +31,19 @@ enum AttrError { fn handle_errors(sess: &ParseSess, span: Span, error: AttrError) { let diag = &sess.span_diagnostic; match error { - AttrError::MultipleItem(item) => span_err!(diag, span, E0538, - "multiple '{}' items", item), + AttrError::MultipleItem(item) => span_err!(diag, span, E0538, "multiple '{}' items", item), AttrError::UnknownMetaItem(item, expected) => { - let expected = expected - .iter() - .map(|name| format!("`{}`", name)) - .collect::<Vec<_>>(); + let expected = expected.iter().map(|name| format!("`{}`", name)).collect::<Vec<_>>(); struct_span_err!(diag, span, E0541, "unknown meta item '{}'", item) .span_label(span, format!("expected one of {}", expected.join(", "))) .emit(); } AttrError::MissingSince => span_err!(diag, span, E0542, "missing 'since'"), AttrError::MissingFeature => span_err!(diag, span, E0546, "missing 'feature'"), - AttrError::MultipleStabilityLevels => span_err!(diag, span, E0544, - "multiple stability levels"), - AttrError::UnsupportedLiteral( - msg, - is_bytestr, - ) => { + AttrError::MultipleStabilityLevels => { + span_err!(diag, span, E0544, "multiple stability levels") + } + AttrError::UnsupportedLiteral(msg, is_bytestr) => { let mut err = struct_span_err!(diag, span, E0565, "{}", msg); if is_bytestr { if let Ok(lint_str) = sess.source_map().span_to_snippet(span) { @@ -107,10 +101,12 @@ pub fn find_unwind_attr(diagnostic: Option<&Handler>, attrs: &[Attribute]) -> Op .span_suggestions( attr.span, "the allowed arguments are `allowed` and `aborts`", - (vec!["allowed", "aborts"]).into_iter() + (vec!["allowed", "aborts"]) + .into_iter() .map(|s| format!("#[unwind({})]", s)), Applicability::MachineApplicable, - ).emit(); + ) + .emit(); }); } } @@ -121,8 +117,17 @@ pub fn find_unwind_attr(diagnostic: Option<&Handler>, attrs: &[Attribute]) -> Op } /// Represents the #[stable], #[unstable], #[rustc_deprecated] attributes. -#[derive(RustcEncodable, RustcDecodable, Copy, Clone, Debug, - PartialEq, Eq, Hash, HashStable_Generic)] +#[derive( + RustcEncodable, + RustcDecodable, + Copy, + Clone, + Debug, + PartialEq, + Eq, + Hash, + HashStable_Generic +)] pub struct Stability { pub level: StabilityLevel, pub feature: Symbol, @@ -130,8 +135,17 @@ pub struct Stability { } /// Represents the #[rustc_const_unstable] and #[rustc_const_stable] attributes. -#[derive(RustcEncodable, RustcDecodable, Copy, Clone, Debug, - PartialEq, Eq, Hash, HashStable_Generic)] +#[derive( + RustcEncodable, + RustcDecodable, + Copy, + Clone, + Debug, + PartialEq, + Eq, + Hash, + HashStable_Generic +)] pub struct ConstStability { pub level: StabilityLevel, pub feature: Symbol, @@ -142,8 +156,18 @@ pub struct ConstStability { } /// The available stability levels. -#[derive(RustcEncodable, RustcDecodable, PartialEq, PartialOrd, - Copy, Clone, Debug, Eq, Hash, HashStable_Generic)] +#[derive( + RustcEncodable, + RustcDecodable, + PartialEq, + PartialOrd, + Copy, + Clone, + Debug, + Eq, + Hash, + HashStable_Generic +)] pub enum StabilityLevel { // Reason for the current stability level and the relevant rust-lang issue Unstable { reason: Option<Symbol>, issue: Option<NonZeroU32>, is_soft: bool }, @@ -152,23 +176,25 @@ pub enum StabilityLevel { impl StabilityLevel { pub fn is_unstable(&self) -> bool { - if let StabilityLevel::Unstable {..} = *self { - true - } else { - false - } + if let StabilityLevel::Unstable { .. } = *self { true } else { false } } pub fn is_stable(&self) -> bool { - if let StabilityLevel::Stable {..} = *self { - true - } else { - false - } + if let StabilityLevel::Stable { .. } = *self { true } else { false } } } -#[derive(RustcEncodable, RustcDecodable, PartialEq, PartialOrd, - Copy, Clone, Debug, Eq, Hash, HashStable_Generic)] +#[derive( + RustcEncodable, + RustcDecodable, + PartialEq, + PartialOrd, + Copy, + Clone, + Debug, + Eq, + Hash, + HashStable_Generic +)] pub struct RustcDeprecation { pub since: Symbol, pub reason: Symbol, @@ -180,25 +206,31 @@ pub struct RustcDeprecation { /// This will not perform any "sanity checks" on the form of the attributes. pub fn contains_feature_attr(attrs: &[Attribute], feature_name: Symbol) -> bool { attrs.iter().any(|item| { - item.check_name(sym::feature) && - item.meta_item_list().map(|list| { - list.iter().any(|mi| mi.is_word() && mi.check_name(feature_name)) - }).unwrap_or(false) + item.check_name(sym::feature) + && item + .meta_item_list() + .map(|list| list.iter().any(|mi| mi.is_word() && mi.check_name(feature_name))) + .unwrap_or(false) }) } /// Collects stability info from all stability attributes in `attrs`. /// Returns `None` if no stability attributes are found. -pub fn find_stability(sess: &ParseSess, attrs: &[Attribute], - item_sp: Span) -> (Option<Stability>, Option<ConstStability>) { +pub fn find_stability( + sess: &ParseSess, + attrs: &[Attribute], + item_sp: Span, +) -> (Option<Stability>, Option<ConstStability>) { find_stability_generic(sess, attrs.iter(), item_sp) } -fn find_stability_generic<'a, I>(sess: &ParseSess, - attrs_iter: I, - item_sp: Span) - -> (Option<Stability>, Option<ConstStability>) - where I: Iterator<Item = &'a Attribute> +fn find_stability_generic<'a, I>( + sess: &ParseSess, + attrs_iter: I, + item_sp: Span, +) -> (Option<Stability>, Option<ConstStability>) +where + I: Iterator<Item = &'a Attribute>, { use StabilityLevel::*; @@ -218,8 +250,11 @@ fn find_stability_generic<'a, I>(sess: &ParseSess, sym::stable, sym::rustc_promotable, sym::rustc_allow_const_fn_ptr, - ].iter().any(|&s| attr.has_name(s)) { - continue // not a stability level + ] + .iter() + .any(|&s| attr.has_name(s)) + { + continue; // not a stability level } mark_used(attr); @@ -242,7 +277,7 @@ fn find_stability_generic<'a, I>(sess: &ParseSess, meta.span, AttrError::MultipleItem(pprust::path_to_string(&meta.path)), ); - return false + return false; } if let Some(v) = meta.value_str() { *item = Some(v); @@ -296,39 +331,38 @@ fn find_stability_generic<'a, I>(sess: &ParseSess, match meta_name { sym::rustc_deprecated => { if rustc_depr.is_some() { - span_err!(diagnostic, item_sp, E0540, - "multiple rustc_deprecated attributes"); - continue 'outer + span_err!( + diagnostic, + item_sp, + E0540, + "multiple rustc_deprecated attributes" + ); + continue 'outer; } get_meta!(since, reason, suggestion); match (since, reason) { (Some(since), Some(reason)) => { - rustc_depr = Some(RustcDeprecation { - since, - reason, - suggestion, - }) + rustc_depr = Some(RustcDeprecation { since, reason, suggestion }) } (None, _) => { handle_errors(sess, attr.span, AttrError::MissingSince); - continue + continue; } _ => { span_err!(diagnostic, attr.span, E0543, "missing 'reason'"); - continue + continue; } } } - sym::rustc_const_unstable | - sym::unstable => { + sym::rustc_const_unstable | sym::unstable => { if meta_name == sym::unstable && stab.is_some() { handle_errors(sess, attr.span, AttrError::MultipleStabilityLevels); - break + break; } else if meta_name == sym::rustc_const_unstable && const_stab.is_some() { handle_errors(sess, attr.span, AttrError::MultipleStabilityLevels); - break + break; } let mut feature = None; @@ -338,9 +372,21 @@ fn find_stability_generic<'a, I>(sess: &ParseSess, for meta in metas { if let Some(mi) = meta.meta_item() { match mi.name_or_empty() { - sym::feature => if !get(mi, &mut feature) { continue 'outer }, - sym::reason => if !get(mi, &mut reason) { continue 'outer }, - sym::issue => if !get(mi, &mut issue) { continue 'outer }, + sym::feature => { + if !get(mi, &mut feature) { + continue 'outer; + } + } + sym::reason => { + if !get(mi, &mut reason) { + continue 'outer; + } + } + sym::issue => { + if !get(mi, &mut issue) { + continue 'outer; + } + } sym::soft => { if !mi.is_word() { let msg = "`soft` should not have any arguments"; @@ -354,22 +400,19 @@ fn find_stability_generic<'a, I>(sess: &ParseSess, meta.span(), AttrError::UnknownMetaItem( pprust::path_to_string(&mi.path), - &["feature", "reason", "issue", "soft"] + &["feature", "reason", "issue", "soft"], ), ); - continue 'outer + continue 'outer; } } } else { handle_errors( sess, meta.span(), - AttrError::UnsupportedLiteral( - "unsupported literal", - false, - ), + AttrError::UnsupportedLiteral("unsupported literal", false), ); - continue 'outer + continue 'outer; } } @@ -389,21 +432,13 @@ fn find_stability_generic<'a, I>(sess: &ParseSess, E0545, "incorrect 'issue'" ); - continue + continue; } } }; - let level = Unstable { - reason, - issue, - is_soft, - }; + let level = Unstable { reason, issue, is_soft }; if sym::unstable == meta_name { - stab = Some(Stability { - level, - feature, - rustc_depr: None, - }); + stab = Some(Stability { level, feature, rustc_depr: None }); } else { const_stab = Some(ConstStability { level, @@ -415,68 +450,66 @@ fn find_stability_generic<'a, I>(sess: &ParseSess, } (None, _, _) => { handle_errors(sess, attr.span, AttrError::MissingFeature); - continue + continue; } _ => { span_err!(diagnostic, attr.span, E0547, "missing 'issue'"); - continue + continue; } } } - sym::rustc_const_stable | - sym::stable => { + sym::rustc_const_stable | sym::stable => { if meta_name == sym::stable && stab.is_some() { handle_errors(sess, attr.span, AttrError::MultipleStabilityLevels); - break - } else if meta_name == sym::rustc_const_stable &&const_stab.is_some() { + break; + } else if meta_name == sym::rustc_const_stable && const_stab.is_some() { handle_errors(sess, attr.span, AttrError::MultipleStabilityLevels); - break + break; } let mut feature = None; let mut since = None; for meta in metas { match meta { - NestedMetaItem::MetaItem(mi) => { - match mi.name_or_empty() { - sym::feature => if !get(mi, &mut feature) { continue 'outer }, - sym::since => if !get(mi, &mut since) { continue 'outer }, - _ => { - handle_errors( - sess, - meta.span(), - AttrError::UnknownMetaItem( - pprust::path_to_string(&mi.path), - &["since", "note"], - ), - ); - continue 'outer + NestedMetaItem::MetaItem(mi) => match mi.name_or_empty() { + sym::feature => { + if !get(mi, &mut feature) { + continue 'outer; + } + } + sym::since => { + if !get(mi, &mut since) { + continue 'outer; } } + _ => { + handle_errors( + sess, + meta.span(), + AttrError::UnknownMetaItem( + pprust::path_to_string(&mi.path), + &["since", "note"], + ), + ); + continue 'outer; + } }, NestedMetaItem::Literal(lit) => { handle_errors( sess, lit.span, - AttrError::UnsupportedLiteral( - "unsupported literal", - false, - ), + AttrError::UnsupportedLiteral("unsupported literal", false), ); - continue 'outer + continue 'outer; } } } match (feature, since) { (Some(feature), Some(since)) => { - let level = Stable { since }; + let level = Stable { since }; if sym::stable == meta_name { - stab = Some(Stability { - level, - feature, - rustc_depr: None, - }); + stab = Some(Stability { level, feature, rustc_depr: None }); } else { const_stab = Some(ConstStability { level, @@ -488,15 +521,15 @@ fn find_stability_generic<'a, I>(sess: &ParseSess, } (None, _) => { handle_errors(sess, attr.span, AttrError::MissingFeature); - continue + continue; } _ => { handle_errors(sess, attr.span, AttrError::MissingSince); - continue + continue; } } } - _ => unreachable!() + _ => unreachable!(), } } } @@ -506,9 +539,13 @@ fn find_stability_generic<'a, I>(sess: &ParseSess, if let Some(ref mut stab) = stab { stab.rustc_depr = Some(rustc_depr); } else { - span_err!(diagnostic, item_sp, E0549, - "rustc_deprecated attribute must be paired with \ - either stable or unstable attribute"); + span_err!( + diagnostic, + item_sp, + E0549, + "rustc_deprecated attribute must be paired with \ + either stable or unstable attribute" + ); } } @@ -518,10 +555,14 @@ fn find_stability_generic<'a, I>(sess: &ParseSess, stab.promotable = promotable; stab.allow_const_fn_ptr = allow_const_fn_ptr; } else { - span_err!(diagnostic, item_sp, E0717, - "rustc_promotable and rustc_allow_const_fn_ptr attributes \ + span_err!( + diagnostic, + item_sp, + E0717, + "rustc_promotable and rustc_allow_const_fn_ptr attributes \ must be paired with either a rustc_const_unstable or a rustc_const_stable \ - attribute"); + attribute" + ); } } @@ -539,7 +580,10 @@ pub fn cfg_matches(cfg: &ast::MetaItem, sess: &ParseSess, features: Option<&Feat if let (Some(feats), Some(gated_cfg)) = (features, gate) { gate_cfg(&gated_cfg, cfg.span, sess, feats); } - let error = |span, msg| { sess.span_diagnostic.span_err(span, msg); true }; + let error = |span, msg| { + sess.span_diagnostic.span_err(span, msg); + true + }; if cfg.path.segments.len() != 1 { return error(cfg.path.span, "`cfg` predicate key must be an identifier"); } @@ -553,7 +597,7 @@ pub fn cfg_matches(cfg: &ast::MetaItem, sess: &ParseSess, features: Option<&Feat lit.span, AttrError::UnsupportedLiteral( "literal in `cfg` predicate value must be a string", - lit.kind.is_bytestr() + lit.kind.is_bytestr(), ), ); true @@ -588,10 +632,7 @@ pub fn eval_condition( handle_errors( sess, mi.span(), - AttrError::UnsupportedLiteral( - "unsupported literal", - false - ), + AttrError::UnsupportedLiteral("unsupported literal", false), ); return false; } @@ -600,12 +641,12 @@ pub fn eval_condition( // The unwraps below may look dangerous, but we've already asserted // that they won't fail with the loop above. match cfg.name_or_empty() { - sym::any => mis.iter().any(|mi| { - eval_condition(mi.meta_item().unwrap(), sess, eval) - }), - sym::all => mis.iter().all(|mi| { - eval_condition(mi.meta_item().unwrap(), sess, eval) - }), + sym::any => { + mis.iter().any(|mi| eval_condition(mi.meta_item().unwrap(), sess, eval)) + } + sym::all => { + mis.iter().all(|mi| eval_condition(mi.meta_item().unwrap(), sess, eval)) + } sym::not => { if mis.len() != 1 { span_err!(sess.span_diagnostic, cfg.span, E0536, "expected 1 cfg-pattern"); @@ -613,20 +654,20 @@ pub fn eval_condition( } !eval_condition(mis[0].meta_item().unwrap(), sess, eval) - }, + } _ => { span_err!( - sess.span_diagnostic, cfg.span, E0537, + sess.span_diagnostic, + cfg.span, + E0537, "invalid predicate `{}`", pprust::path_to_string(&cfg.path) ); false } } - }, - ast::MetaItemKind::Word | ast::MetaItemKind::NameValue(..) => { - eval(cfg) } + ast::MetaItemKind::Word | ast::MetaItemKind::NameValue(..) => eval(cfg), } } @@ -637,16 +678,21 @@ pub struct Deprecation { } /// Finds the deprecation attribute. `None` if none exists. -pub fn find_deprecation(sess: &ParseSess, attrs: &[Attribute], - item_sp: Span) -> Option<Deprecation> { +pub fn find_deprecation( + sess: &ParseSess, + attrs: &[Attribute], + item_sp: Span, +) -> Option<Deprecation> { find_deprecation_generic(sess, attrs.iter(), item_sp) } -fn find_deprecation_generic<'a, I>(sess: &ParseSess, - attrs_iter: I, - item_sp: Span) - -> Option<Deprecation> - where I: Iterator<Item = &'a Attribute> +fn find_deprecation_generic<'a, I>( + sess: &ParseSess, + attrs_iter: I, + item_sp: Span, +) -> Option<Deprecation> +where + I: Iterator<Item = &'a Attribute>, { let mut depr: Option<Deprecation> = None; let diagnostic = &sess.span_diagnostic; @@ -658,7 +704,7 @@ fn find_deprecation_generic<'a, I>(sess: &ParseSess, if depr.is_some() { span_err!(diagnostic, item_sp, E0550, "multiple deprecated attributes"); - break + break; } let meta = match attr.meta() { @@ -668,9 +714,7 @@ fn find_deprecation_generic<'a, I>(sess: &ParseSess, depr = match &meta.kind { MetaItemKind::Word => Some(Deprecation { since: None, note: None }), MetaItemKind::NameValue(..) => { - meta.value_str().map(|note| { - Deprecation { since: None, note: Some(note) } - }) + meta.value_str().map(|note| Deprecation { since: None, note: Some(note) }) } MetaItemKind::List(list) => { let get = |meta: &MetaItem, item: &mut Option<Symbol>| { @@ -680,7 +724,7 @@ fn find_deprecation_generic<'a, I>(sess: &ParseSess, meta.span, AttrError::MultipleItem(pprust::path_to_string(&meta.path)), ); - return false + return false; } if let Some(v) = meta.value_str() { *item = Some(v); @@ -693,7 +737,7 @@ fn find_deprecation_generic<'a, I>(sess: &ParseSess, AttrError::UnsupportedLiteral( "literal in `deprecated` \ value must be a string", - lit.kind.is_bytestr() + lit.kind.is_bytestr(), ), ); } else { @@ -708,23 +752,29 @@ fn find_deprecation_generic<'a, I>(sess: &ParseSess, let mut note = None; for meta in list { match meta { - NestedMetaItem::MetaItem(mi) => { - match mi.name_or_empty() { - sym::since => if !get(mi, &mut since) { continue 'outer }, - sym::note => if !get(mi, &mut note) { continue 'outer }, - _ => { - handle_errors( - sess, - meta.span(), - AttrError::UnknownMetaItem( - pprust::path_to_string(&mi.path), - &["since", "note"], - ), - ); - continue 'outer + NestedMetaItem::MetaItem(mi) => match mi.name_or_empty() { + sym::since => { + if !get(mi, &mut since) { + continue 'outer; } } - } + sym::note => { + if !get(mi, &mut note) { + continue 'outer; + } + } + _ => { + handle_errors( + sess, + meta.span(), + AttrError::UnknownMetaItem( + pprust::path_to_string(&mi.path), + &["since", "note"], + ), + ); + continue 'outer; + } + }, NestedMetaItem::Literal(lit) => { handle_errors( sess, @@ -734,7 +784,7 @@ fn find_deprecation_generic<'a, I>(sess: &ParseSess, false, ), ); - continue 'outer + continue 'outer; } } } @@ -760,7 +810,7 @@ pub enum ReprAttr { #[derive(Eq, PartialEq, Debug, RustcEncodable, RustcDecodable, Copy, Clone, HashStable_Generic)] pub enum IntType { SignedInt(ast::IntTy), - UnsignedInt(ast::UintTy) + UnsignedInt(ast::UintTy), } impl IntType { @@ -770,7 +820,7 @@ impl IntType { match self { SignedInt(..) => true, - UnsignedInt(..) => false + UnsignedInt(..) => false, } } } @@ -800,7 +850,7 @@ pub fn find_repr_attrs(sess: &ParseSess, attr: &Attribute) -> Vec<ReprAttr> { false, ), ); - continue + continue; } let mut recognised = false; @@ -840,34 +890,42 @@ pub fn find_repr_attrs(sess: &ParseSess, attr: &Attribute) -> Vec<ReprAttr> { recognised = true; match parse_alignment(&value.kind) { Ok(literal) => acc.push(ReprAlign(literal)), - Err(message) => literal_error = Some(message) + Err(message) => literal_error = Some(message), }; - } - else if name == sym::packed { + } else if name == sym::packed { recognised = true; match parse_alignment(&value.kind) { Ok(literal) => acc.push(ReprPacked(literal)), - Err(message) => literal_error = Some(message) + Err(message) => literal_error = Some(message), }; } if let Some(literal_error) = literal_error { - span_err!(diagnostic, item.span(), E0589, - "invalid `repr(align)` attribute: {}", literal_error); + span_err!( + diagnostic, + item.span(), + E0589, + "invalid `repr(align)` attribute: {}", + literal_error + ); } } else { if let Some(meta_item) = item.meta_item() { if meta_item.check_name(sym::align) { if let MetaItemKind::NameValue(ref value) = meta_item.kind { recognised = true; - let mut err = struct_span_err!(diagnostic, item.span(), E0693, - "incorrect `repr(align)` attribute format"); + let mut err = struct_span_err!( + diagnostic, + item.span(), + E0693, + "incorrect `repr(align)` attribute format" + ); match value.kind { ast::LitKind::Int(int, ast::LitIntType::Unsuffixed) => { err.span_suggestion( item.span(), "use parentheses instead", format!("align({})", int), - Applicability::MachineApplicable + Applicability::MachineApplicable, ); } ast::LitKind::Str(s, _) => { @@ -875,7 +933,7 @@ pub fn find_repr_attrs(sess: &ParseSess, attr: &Attribute) -> Vec<ReprAttr> { item.span(), "use parentheses instead", format!("align({})", s), - Applicability::MachineApplicable + Applicability::MachineApplicable, ); } _ => {} @@ -887,8 +945,7 @@ pub fn find_repr_attrs(sess: &ParseSess, attr: &Attribute) -> Vec<ReprAttr> { } if !recognised { // Not a word we recognize - span_err!(diagnostic, item.span(), E0552, - "unrecognized representation hint"); + span_err!(diagnostic, item.span(), E0552, "unrecognized representation hint"); } } } @@ -912,7 +969,7 @@ fn int_type_of_word(s: Symbol) -> Option<IntType> { sym::u128 => Some(UnsignedInt(ast::UintTy::U128)), sym::isize => Some(SignedInt(ast::IntTy::Isize)), sym::usize => Some(UnsignedInt(ast::UintTy::Usize)), - _ => None + _ => None, } } @@ -922,7 +979,8 @@ pub enum TransparencyError { } pub fn find_transparency( - attrs: &[Attribute], is_legacy: bool + attrs: &[Attribute], + is_legacy: bool, ) -> (Transparency, Option<TransparencyError>) { let mut transparency = None; let mut error = None; @@ -932,15 +990,18 @@ pub fn find_transparency( error = Some(TransparencyError::MultipleTransparencyAttrs(old_span, attr.span)); break; } else if let Some(value) = attr.value_str() { - transparency = Some((match &*value.as_str() { - "transparent" => Transparency::Transparent, - "semitransparent" => Transparency::SemiTransparent, - "opaque" => Transparency::Opaque, - _ => { - error = Some(TransparencyError::UnknownTransparency(value, attr.span)); - continue; - } - }, attr.span)); + transparency = Some(( + match &*value.as_str() { + "transparent" => Transparency::Transparent, + "semitransparent" => Transparency::SemiTransparent, + "opaque" => Transparency::Opaque, + _ => { + error = Some(TransparencyError::UnknownTransparency(value, attr.span)); + continue; + } + }, + attr.span, + )); } } } diff --git a/src/libsyntax/attr/mod.rs b/src/libsyntax/attr/mod.rs index ae6d50ba083..82685e98386 100644 --- a/src/libsyntax/attr/mod.rs +++ b/src/libsyntax/attr/mod.rs @@ -2,21 +2,21 @@ mod builtin; +pub use crate::ast::Attribute; pub use builtin::*; pub use IntType::*; pub use ReprAttr::*; pub use StabilityLevel::*; -pub use crate::ast::Attribute; use crate::ast; -use crate::ast::{AttrVec, AttrItem, AttrId, AttrKind, AttrStyle, Name, Ident, Path, PathSegment}; +use crate::ast::{AttrId, AttrItem, AttrKind, AttrStyle, AttrVec, Ident, Name, Path, PathSegment}; +use crate::ast::{Expr, GenericParam, Item, Lit, LitKind, Local, Stmt, StmtKind}; use crate::ast::{MacArgs, MacDelimiter, MetaItem, MetaItemKind, NestedMetaItem}; -use crate::ast::{Lit, LitKind, Expr, Item, Local, Stmt, StmtKind, GenericParam}; use crate::mut_visit::visit_clobber; -use crate::source_map::{BytePos, Spanned}; -use crate::token::{self, Token}; use crate::ptr::P; +use crate::source_map::{BytePos, Spanned}; use crate::symbol::{sym, Symbol}; +use crate::token::{self, Token}; use crate::tokenstream::{DelimSpan, TokenStream, TokenTree, TreeAndJoint}; use crate::GLOBALS; @@ -34,9 +34,7 @@ pub fn mark_used(attr: &Attribute) { } pub fn is_used(attr: &Attribute) -> bool { - GLOBALS.with(|globals| { - globals.used_attrs.lock().contains(attr.id) - }) + GLOBALS.with(|globals| globals.used_attrs.lock().contains(attr.id)) } pub fn mark_known(attr: &Attribute) { @@ -47,9 +45,7 @@ pub fn mark_known(attr: &Attribute) { } pub fn is_known(attr: &Attribute) -> bool { - GLOBALS.with(|globals| { - globals.known_attrs.lock().contains(attr.id) - }) + GLOBALS.with(|globals| globals.known_attrs.lock().contains(attr.id)) } pub fn is_known_lint_tool(m_item: Ident) -> bool { @@ -61,7 +57,7 @@ impl NestedMetaItem { pub fn meta_item(&self) -> Option<&MetaItem> { match *self { NestedMetaItem::MetaItem(ref item) => Some(item), - _ => None + _ => None, } } @@ -69,7 +65,7 @@ impl NestedMetaItem { pub fn literal(&self) -> Option<&Lit> { match *self { NestedMetaItem::Literal(ref lit) => Some(lit), - _ => None + _ => None, } } @@ -94,18 +90,18 @@ impl NestedMetaItem { /// Returns a name and single literal value tuple of the `MetaItem`. pub fn name_value_literal(&self) -> Option<(Name, &Lit)> { - self.meta_item().and_then( - |meta_item| meta_item.meta_item_list().and_then( - |meta_item_list| { - if meta_item_list.len() == 1 { - if let Some(ident) = meta_item.ident() { - if let Some(lit) = meta_item_list[0].literal() { - return Some((ident.name, lit)); - } + self.meta_item().and_then(|meta_item| { + meta_item.meta_item_list().and_then(|meta_item_list| { + if meta_item_list.len() == 1 { + if let Some(ident) = meta_item.ident() { + if let Some(lit) = meta_item_list[0].literal() { + return Some((ident.name, lit)); } } - None - })) + } + None + }) + }) } /// Gets a list of inner meta items from a list `MetaItem` type. @@ -176,21 +172,17 @@ impl Attribute { pub fn value_str(&self) -> Option<Symbol> { match self.kind { - AttrKind::Normal(ref item) => { - item.meta(self.span).and_then(|meta| meta.value_str()) - } + AttrKind::Normal(ref item) => item.meta(self.span).and_then(|meta| meta.value_str()), AttrKind::DocComment(comment) => Some(comment), } } pub fn meta_item_list(&self) -> Option<Vec<NestedMetaItem>> { match self.kind { - AttrKind::Normal(ref item) => { - match item.meta(self.span) { - Some(MetaItem { kind: MetaItemKind::List(list), .. }) => Some(list), - _ => None - } - } + AttrKind::Normal(ref item) => match item.meta(self.span) { + Some(MetaItem { kind: MetaItemKind::List(list), .. }) => Some(list), + _ => None, + }, AttrKind::DocComment(_) => None, } } @@ -216,11 +208,7 @@ impl Attribute { impl MetaItem { /// For a single-segment meta item, returns its name; otherwise, returns `None`. pub fn ident(&self) -> Option<Ident> { - if self.path.segments.len() == 1 { - Some(self.path.segments[0].ident) - } else { - None - } + if self.path.segments.len() == 1 { Some(self.path.segments[0].ident) } else { None } } pub fn name_or_empty(&self) -> Symbol { self.ident().unwrap_or(Ident::invalid()).name @@ -238,20 +226,18 @@ impl MetaItem { pub fn value_str(&self) -> Option<Symbol> { match self.kind { - MetaItemKind::NameValue(ref v) => { - match v.kind { - LitKind::Str(ref s, _) => Some(*s), - _ => None, - } + MetaItemKind::NameValue(ref v) => match v.kind { + LitKind::Str(ref s, _) => Some(*s), + _ => None, }, - _ => None + _ => None, } } pub fn meta_item_list(&self) -> Option<&[NestedMetaItem]> { match self.kind { MetaItemKind::List(ref l) => Some(&l[..]), - _ => None + _ => None, } } @@ -311,8 +297,9 @@ impl Attribute { pub fn meta(&self) -> Option<MetaItem> { match self.kind { AttrKind::Normal(ref item) => item.meta(self.span), - AttrKind::DocComment(comment) => - Some(mk_name_value_item_str(Ident::new(sym::doc, self.span), comment, self.span)), + AttrKind::DocComment(comment) => { + Some(mk_name_value_item_str(Ident::new(sym::doc, self.span), comment, self.span)) + } } } } @@ -358,12 +345,7 @@ pub fn mk_attr(style: AttrStyle, path: Path, args: MacArgs, span: Span) -> Attri } pub fn mk_attr_from_item(style: AttrStyle, item: AttrItem, span: Span) -> Attribute { - Attribute { - kind: AttrKind::Normal(item), - id: mk_attr_id(), - style, - span, - } + Attribute { kind: AttrKind::Normal(item), id: mk_attr_id(), style, span } } /// Returns an inner attribute with the given value and span. @@ -377,24 +359,15 @@ pub fn mk_attr_outer(item: MetaItem) -> Attribute { } pub fn mk_doc_comment(style: AttrStyle, comment: Symbol, span: Span) -> Attribute { - Attribute { - kind: AttrKind::DocComment(comment), - id: mk_attr_id(), - style, - span, - } + Attribute { kind: AttrKind::DocComment(comment), id: mk_attr_id(), style, span } } pub fn list_contains_name(items: &[NestedMetaItem], name: Symbol) -> bool { - items.iter().any(|item| { - item.check_name(name) - }) + items.iter().any(|item| item.check_name(name)) } pub fn contains_name(attrs: &[Attribute], name: Symbol) -> bool { - attrs.iter().any(|item| { - item.check_name(name) - }) + attrs.iter().any(|item| item.check_name(name)) } pub fn find_by_name(attrs: &[Attribute], name: Symbol) -> Option<&Attribute> { @@ -406,34 +379,31 @@ pub fn allow_internal_unstable<'a>( span_diagnostic: &'a errors::Handler, ) -> Option<impl Iterator<Item = Symbol> + 'a> { find_by_name(attrs, sym::allow_internal_unstable).and_then(|attr| { - attr.meta_item_list().or_else(|| { - span_diagnostic.span_err( - attr.span, - "allow_internal_unstable expects list of feature names" - ); - None - }).map(|features| features.into_iter().filter_map(move |it| { - let name = it.ident().map(|ident| ident.name); - if name.is_none() { - span_diagnostic.span_err( - it.span(), - "`allow_internal_unstable` expects feature names", - ) - } - name - })) + attr.meta_item_list() + .or_else(|| { + span_diagnostic + .span_err(attr.span, "allow_internal_unstable expects list of feature names"); + None + }) + .map(|features| { + features.into_iter().filter_map(move |it| { + let name = it.ident().map(|ident| ident.name); + if name.is_none() { + span_diagnostic + .span_err(it.span(), "`allow_internal_unstable` expects feature names") + } + name + }) + }) }) } -pub fn filter_by_name(attrs: &[Attribute], name: Symbol) - -> impl Iterator<Item=&Attribute> { +pub fn filter_by_name(attrs: &[Attribute], name: Symbol) -> impl Iterator<Item = &Attribute> { attrs.iter().filter(move |attr| attr.check_name(name)) } pub fn first_attr_value_str_by_name(attrs: &[Attribute], name: Symbol) -> Option<Symbol> { - attrs.iter() - .find(|at| at.check_name(name)) - .and_then(|at| at.value_str()) + attrs.iter().find(|at| at.check_name(name)).and_then(|at| at.value_str()) } impl MetaItem { @@ -443,9 +413,8 @@ impl MetaItem { for (i, segment) in self.path.segments.iter().enumerate() { let is_first = i == 0; if !is_first { - let mod_sep_span = Span::new(last_pos, - segment.ident.span.lo(), - segment.ident.span.ctxt()); + let mod_sep_span = + Span::new(last_pos, segment.ident.span.lo(), segment.ident.span.ctxt()); idents.push(TokenTree::token(token::ModSep, mod_sep_span).into()); } idents.push(TokenTree::Token(Token::from_ast_ident(segment.ident)).into()); @@ -456,15 +425,16 @@ impl MetaItem { } fn from_tokens<I>(tokens: &mut iter::Peekable<I>) -> Option<MetaItem> - where I: Iterator<Item = TokenTree>, + where + I: Iterator<Item = TokenTree>, { // FIXME: Share code with `parse_path`. let path = match tokens.next() { - Some(TokenTree::Token(Token { kind: kind @ token::Ident(..), span })) | - Some(TokenTree::Token(Token { kind: kind @ token::ModSep, span })) => 'arm: { + Some(TokenTree::Token(Token { kind: kind @ token::Ident(..), span })) + | Some(TokenTree::Token(Token { kind: kind @ token::ModSep, span })) => 'arm: { let mut segments = if let token::Ident(name, _) = kind { - if let Some(TokenTree::Token(Token { kind: token::ModSep, .. })) - = tokens.peek() { + if let Some(TokenTree::Token(Token { kind: token::ModSep, .. })) = tokens.peek() + { tokens.next(); vec![PathSegment::from_ident(Ident::new(name, span))] } else { @@ -474,14 +444,15 @@ impl MetaItem { vec![PathSegment::path_root(span)] }; loop { - if let Some(TokenTree::Token(Token { kind: token::Ident(name, _), span })) - = tokens.next() { + if let Some(TokenTree::Token(Token { kind: token::Ident(name, _), span })) = + tokens.next() + { segments.push(PathSegment::from_ident(Ident::new(name, span))); } else { return None; } - if let Some(TokenTree::Token(Token { kind: token::ModSep, .. })) - = tokens.peek() { + if let Some(TokenTree::Token(Token { kind: token::ModSep, .. })) = tokens.peek() + { tokens.next(); } else { break; @@ -524,7 +495,9 @@ impl MetaItemKind { tts.extend(item.token_trees_and_joints()) } MacArgs::Delimited( - DelimSpan::from_single(span), MacDelimiter::Parenthesis, TokenStream::new(tts) + DelimSpan::from_single(span), + MacDelimiter::Parenthesis, + TokenStream::new(tts), ) } } @@ -534,10 +507,7 @@ impl MetaItemKind { match *self { MetaItemKind::Word => vec![], MetaItemKind::NameValue(ref lit) => { - vec![ - TokenTree::token(token::Eq, span).into(), - lit.token_tree().into(), - ] + vec![TokenTree::token(token::Eq, span).into(), lit.token_tree().into()] } MetaItemKind::List(ref list) => { let mut tokens = Vec::new(); @@ -552,7 +522,8 @@ impl MetaItemKind { DelimSpan::from_single(span), token::Paren, TokenStream::new(tokens).into(), - ).into() + ) + .into(), ] } } @@ -576,16 +547,18 @@ impl MetaItemKind { tokens: &mut impl Iterator<Item = TokenTree>, ) -> Option<MetaItemKind> { match tokens.next() { - Some(TokenTree::Token(token)) => - Lit::from_token(&token).ok().map(MetaItemKind::NameValue), + Some(TokenTree::Token(token)) => { + Lit::from_token(&token).ok().map(MetaItemKind::NameValue) + } _ => None, } } fn from_mac_args(args: &MacArgs) -> Option<MetaItemKind> { match args { - MacArgs::Delimited(_, MacDelimiter::Parenthesis, tokens) => - MetaItemKind::list_from_tokens(tokens.clone()), + MacArgs::Delimited(_, MacDelimiter::Parenthesis, tokens) => { + MetaItemKind::list_from_tokens(tokens.clone()) + } MacArgs::Delimited(..) => None, MacArgs::Eq(_, tokens) => { assert!(tokens.len() == 1); @@ -630,7 +603,8 @@ impl NestedMetaItem { } fn from_tokens<I>(tokens: &mut iter::Peekable<I>) -> Option<NestedMetaItem> - where I: Iterator<Item = TokenTree>, + where + I: Iterator<Item = TokenTree>, { if let Some(TokenTree::Token(token)) = tokens.peek() { if let Ok(lit) = Lit::from_token(token) { @@ -649,7 +623,9 @@ pub trait HasAttrs: Sized { } impl<T: HasAttrs> HasAttrs for Spanned<T> { - fn attrs(&self) -> &[ast::Attribute] { self.node.attrs() } + fn attrs(&self) -> &[ast::Attribute] { + self.node.attrs() + } fn visit_attrs<F: FnOnce(&mut Vec<ast::Attribute>)>(&mut self, f: F) { self.node.visit_attrs(f); } diff --git a/src/libsyntax/diagnostics/macros.rs b/src/libsyntax/diagnostics/macros.rs index 6679b4459a0..4ed17418c30 100644 --- a/src/libsyntax/diagnostics/macros.rs +++ b/src/libsyntax/diagnostics/macros.rs @@ -1,8 +1,8 @@ #[macro_export] macro_rules! diagnostic_used { - ($code:ident) => ( + ($code:ident) => { let _ = $code; - ) + }; } #[macro_export] @@ -98,10 +98,10 @@ macro_rules! struct_span_err { #[macro_export] macro_rules! stringify_error_code { - ($code:ident) => ({ + ($code:ident) => {{ $crate::diagnostic_used!($code); $crate::errors::DiagnosticId::Error(stringify!($code).to_owned()) - }) + }}; } #[macro_export] diff --git a/src/libsyntax/early_buffered_lints.rs b/src/libsyntax/early_buffered_lints.rs index 2c32894a23b..7724107888a 100644 --- a/src/libsyntax/early_buffered_lints.rs +++ b/src/libsyntax/early_buffered_lints.rs @@ -3,9 +3,9 @@ //! Since we cannot have a dependency on `librustc`, we implement some types here that are somewhat //! redundant. Later, these types can be converted to types for use by the rest of the compiler. -use rustc_session::lint::FutureIncompatibleInfo; use rustc_session::declare_lint; pub use rustc_session::lint::BufferedEarlyLint; +use rustc_session::lint::FutureIncompatibleInfo; declare_lint! { pub ILL_FORMED_ATTRIBUTE_INPUT, diff --git a/src/libsyntax/entry.rs b/src/libsyntax/entry.rs index 34b5b1e5b5c..a896da5629f 100644 --- a/src/libsyntax/entry.rs +++ b/src/libsyntax/entry.rs @@ -1,5 +1,5 @@ -use crate::attr; use crate::ast::{Item, ItemKind}; +use crate::attr; use crate::symbol::sym; pub enum EntryPointType { diff --git a/src/libsyntax/expand/allocator.rs b/src/libsyntax/expand/allocator.rs index cc3eeed04a6..7ab8e370926 100644 --- a/src/libsyntax/expand/allocator.rs +++ b/src/libsyntax/expand/allocator.rs @@ -55,11 +55,15 @@ pub static ALLOCATOR_METHODS: &[AllocatorMethod] = &[ ]; pub fn global_allocator_spans(krate: &ast::Crate) -> Vec<Span> { - struct Finder { name: Symbol, spans: Vec<Span> } + struct Finder { + name: Symbol, + spans: Vec<Span>, + } impl<'ast> visit::Visitor<'ast> for Finder { fn visit_item(&mut self, item: &'ast ast::Item) { - if item.ident.name == self.name && - attr::contains_name(&item.attrs, sym::rustc_std_internal_symbol) { + if item.ident.name == self.name + && attr::contains_name(&item.attrs, sym::rustc_std_internal_symbol) + { self.spans.push(item.span); } visit::walk_item(self, item) diff --git a/src/libsyntax/expand/mod.rs b/src/libsyntax/expand/mod.rs index 03b30fda745..761dc2f5684 100644 --- a/src/libsyntax/expand/mod.rs +++ b/src/libsyntax/expand/mod.rs @@ -7,5 +7,6 @@ pub mod allocator; pub fn is_proc_macro_attr(attr: &Attribute) -> bool { [sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive] - .iter().any(|kind| attr.check_name(*kind)) + .iter() + .any(|kind| attr.check_name(*kind)) } diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs index aacd14c3af7..6fd926f2048 100644 --- a/src/libsyntax/feature_gate/check.rs +++ b/src/libsyntax/feature_gate/check.rs @@ -1,45 +1,52 @@ -use rustc_feature::{ACCEPTED_FEATURES, ACTIVE_FEATURES, REMOVED_FEATURES, STABLE_REMOVED_FEATURES}; -use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP}; -use rustc_feature::{Features, Feature, State as FeatureState, UnstableFeatures}; use rustc_feature::{find_feature_issue, GateIssue}; +use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP}; +use rustc_feature::{Feature, Features, State as FeatureState, UnstableFeatures}; +use rustc_feature::{ + ACCEPTED_FEATURES, ACTIVE_FEATURES, REMOVED_FEATURES, STABLE_REMOVED_FEATURES, +}; use crate::ast::{self, AssocTyConstraint, AssocTyConstraintKind, NodeId}; use crate::ast::{GenericParam, GenericParamKind, PatKind, RangeEnd, VariantData}; use crate::attr; +use crate::edition::{Edition, ALL_EDITIONS}; +use crate::sess::ParseSess; use crate::source_map::Spanned; -use crate::edition::{ALL_EDITIONS, Edition}; +use crate::symbol::{sym, Symbol}; use crate::visit::{self, FnKind, Visitor}; -use crate::sess::ParseSess; -use crate::symbol::{Symbol, sym}; use errors::{Applicability, DiagnosticBuilder, Handler}; -use rustc_data_structures::fx::FxHashMap; -use syntax_pos::{Span, DUMMY_SP, MultiSpan}; use log::debug; +use rustc_data_structures::fx::FxHashMap; +use syntax_pos::{MultiSpan, Span, DUMMY_SP}; use rustc_error_codes::*; macro_rules! gate_feature_fn { ($cx: expr, $has_feature: expr, $span: expr, $name: expr, $explain: expr, $level: expr) => {{ - let (cx, has_feature, span, - name, explain, level) = (&*$cx, $has_feature, $span, $name, $explain, $level); + let (cx, has_feature, span, name, explain, level) = + (&*$cx, $has_feature, $span, $name, $explain, $level); let has_feature: bool = has_feature(&$cx.features); debug!("gate_feature(feature = {:?}, span = {:?}); has? {}", name, span, has_feature); if !has_feature && !span.allows_unstable($name) { leveled_feature_err(cx.parse_sess, name, span, GateIssue::Language, explain, level) .emit(); } - }} + }}; } macro_rules! gate_feature { ($cx: expr, $feature: ident, $span: expr, $explain: expr) => { - gate_feature_fn!($cx, |x:&Features| x.$feature, $span, - sym::$feature, $explain, GateStrength::Hard) + gate_feature_fn!( + $cx, + |x: &Features| x.$feature, + $span, + sym::$feature, + $explain, + GateStrength::Hard + ) }; ($cx: expr, $feature: ident, $span: expr, $explain: expr, $level: expr) => { - gate_feature_fn!($cx, |x:&Features| x.$feature, $span, - sym::$feature, $explain, $level) + gate_feature_fn!($cx, |x: &Features| x.$feature, $span, sym::$feature, $explain, $level) }; } @@ -111,7 +118,6 @@ fn leveled_feature_err<'a>( } err - } struct PostExpansionVisitor<'a> { @@ -131,7 +137,7 @@ macro_rules! gate_feature_post { if !span.allows_unstable(sym::$feature) { gate_feature!(cx, $feature, span, $explain, $level) } - }} + }}; } impl<'a> PostExpansionVisitor<'a> { @@ -140,65 +146,95 @@ impl<'a> PostExpansionVisitor<'a> { match &*symbol_unescaped.as_str() { // Stable - "Rust" | - "C" | - "cdecl" | - "stdcall" | - "fastcall" | - "aapcs" | - "win64" | - "sysv64" | - "system" => {} + "Rust" | "C" | "cdecl" | "stdcall" | "fastcall" | "aapcs" | "win64" | "sysv64" + | "system" => {} "rust-intrinsic" => { - gate_feature_post!(&self, intrinsics, span, - "intrinsics are subject to change"); - }, + gate_feature_post!(&self, intrinsics, span, "intrinsics are subject to change"); + } "platform-intrinsic" => { - gate_feature_post!(&self, platform_intrinsics, span, - "platform intrinsics are experimental and possibly buggy"); - }, + gate_feature_post!( + &self, + platform_intrinsics, + span, + "platform intrinsics are experimental and possibly buggy" + ); + } "vectorcall" => { - gate_feature_post!(&self, abi_vectorcall, span, - "vectorcall is experimental and subject to change"); - }, + gate_feature_post!( + &self, + abi_vectorcall, + span, + "vectorcall is experimental and subject to change" + ); + } "thiscall" => { - gate_feature_post!(&self, abi_thiscall, span, - "thiscall is experimental and subject to change"); - }, + gate_feature_post!( + &self, + abi_thiscall, + span, + "thiscall is experimental and subject to change" + ); + } "rust-call" => { - gate_feature_post!(&self, unboxed_closures, span, - "rust-call ABI is subject to change"); - }, + gate_feature_post!( + &self, + unboxed_closures, + span, + "rust-call ABI is subject to change" + ); + } "ptx-kernel" => { - gate_feature_post!(&self, abi_ptx, span, - "PTX ABIs are experimental and subject to change"); - }, + gate_feature_post!( + &self, + abi_ptx, + span, + "PTX ABIs are experimental and subject to change" + ); + } "unadjusted" => { - gate_feature_post!(&self, abi_unadjusted, span, - "unadjusted ABI is an implementation detail and perma-unstable"); - }, + gate_feature_post!( + &self, + abi_unadjusted, + span, + "unadjusted ABI is an implementation detail and perma-unstable" + ); + } "msp430-interrupt" => { - gate_feature_post!(&self, abi_msp430_interrupt, span, - "msp430-interrupt ABI is experimental and subject to change"); - }, + gate_feature_post!( + &self, + abi_msp430_interrupt, + span, + "msp430-interrupt ABI is experimental and subject to change" + ); + } "x86-interrupt" => { - gate_feature_post!(&self, abi_x86_interrupt, span, - "x86-interrupt ABI is experimental and subject to change"); - }, + gate_feature_post!( + &self, + abi_x86_interrupt, + span, + "x86-interrupt ABI is experimental and subject to change" + ); + } "amdgpu-kernel" => { - gate_feature_post!(&self, abi_amdgpu_kernel, span, - "amdgpu-kernel ABI is experimental and subject to change"); - }, + gate_feature_post!( + &self, + abi_amdgpu_kernel, + span, + "amdgpu-kernel ABI is experimental and subject to change" + ); + } "efiapi" => { - gate_feature_post!(&self, abi_efiapi, span, - "efiapi ABI is experimental and subject to change"); - }, - abi => { - self.parse_sess.span_diagnostic.delay_span_bug( + gate_feature_post!( + &self, + abi_efiapi, span, - &format!("unrecognized ABI not caught in lowering: {}", abi), - ) + "efiapi ABI is experimental and subject to change" + ); } + abi => self + .parse_sess + .span_diagnostic + .delay_span_bug(span, &format!("unrecognized ABI not caught in lowering: {}", abi)), } } @@ -214,12 +250,14 @@ impl<'a> PostExpansionVisitor<'a> { VariantData::Unit(..) => false, }); - let discriminant_spans = variants.iter().filter(|variant| match variant.data { - VariantData::Tuple(..) | VariantData::Struct(..) => false, - VariantData::Unit(..) => true, - }) - .filter_map(|variant| variant.disr_expr.as_ref().map(|c| c.value.span)) - .collect::<Vec<_>>(); + let discriminant_spans = variants + .iter() + .filter(|variant| match variant.data { + VariantData::Tuple(..) | VariantData::Struct(..) => false, + VariantData::Unit(..) => true, + }) + .filter_map(|variant| variant.disr_expr.as_ref().map(|c| c.value.span)) + .collect::<Vec<_>>(); if !discriminant_spans.is_empty() && has_fields { let mut err = feature_err( @@ -234,16 +272,10 @@ impl<'a> PostExpansionVisitor<'a> { for variant in variants.iter() { match &variant.data { VariantData::Struct(..) => { - err.span_label( - variant.span, - "struct variant defined here", - ); + err.span_label(variant.span, "struct variant defined here"); } VariantData::Tuple(..) => { - err.span_label( - variant.span, - "tuple variant defined here", - ); + err.span_label(variant.span, "tuple variant defined here"); } VariantData::Unit(..) => {} } @@ -344,20 +376,32 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { ast::ItemKind::Fn(..) => { if attr::contains_name(&i.attrs[..], sym::plugin_registrar) { - gate_feature_post!(&self, plugin_registrar, i.span, - "compiler plugins are experimental and possibly buggy"); + gate_feature_post!( + &self, + plugin_registrar, + i.span, + "compiler plugins are experimental and possibly buggy" + ); } if attr::contains_name(&i.attrs[..], sym::start) { - gate_feature_post!(&self, start, i.span, - "a `#[start]` function is an experimental \ + gate_feature_post!( + &self, + start, + i.span, + "a `#[start]` function is an experimental \ feature whose signature may change \ - over time"); + over time" + ); } if attr::contains_name(&i.attrs[..], sym::main) { - gate_feature_post!(&self, main, i.span, - "declaration of a non-standard `#[main]` \ + gate_feature_post!( + &self, + main, + i.span, + "declaration of a non-standard `#[main]` \ function may change over time, for now \ - a top-level `fn main()` is required"); + a top-level `fn main()` is required" + ); } } @@ -365,24 +409,28 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { for attr in attr::filter_by_name(&i.attrs[..], sym::repr) { for item in attr.meta_item_list().unwrap_or_else(Vec::new) { if item.check_name(sym::simd) { - gate_feature_post!(&self, repr_simd, attr.span, - "SIMD types are experimental and possibly buggy"); + gate_feature_post!( + &self, + repr_simd, + attr.span, + "SIMD types are experimental and possibly buggy" + ); } } } } - ast::ItemKind::Enum(ast::EnumDef{ref variants, ..}, ..) => { + ast::ItemKind::Enum(ast::EnumDef { ref variants, .. }, ..) => { for variant in variants { match (&variant.data, &variant.disr_expr) { - (ast::VariantData::Unit(..), _) => {}, - (_, Some(disr_expr)) => - gate_feature_post!( - &self, - arbitrary_enum_discriminant, - disr_expr.value.span, - "discriminants on non-unit variants are experimental"), - _ => {}, + (ast::VariantData::Unit(..), _) => {} + (_, Some(disr_expr)) => gate_feature_post!( + &self, + arbitrary_enum_discriminant, + disr_expr.value.span, + "discriminants on non-unit variants are experimental" + ), + _ => {} } } @@ -394,34 +442,33 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { ast::ItemKind::Impl(_, polarity, defaultness, ..) => { if polarity == ast::ImplPolarity::Negative { - gate_feature_post!(&self, optin_builtin_traits, - i.span, - "negative trait bounds are not yet fully implemented; \ - use marker types for now"); + gate_feature_post!( + &self, + optin_builtin_traits, + i.span, + "negative trait bounds are not yet fully implemented; \ + use marker types for now" + ); } if let ast::Defaultness::Default = defaultness { - gate_feature_post!(&self, specialization, - i.span, - "specialization is unstable"); + gate_feature_post!(&self, specialization, i.span, "specialization is unstable"); } } ast::ItemKind::Trait(ast::IsAuto::Yes, ..) => { - gate_feature_post!(&self, optin_builtin_traits, - i.span, - "auto traits are experimental and possibly buggy"); - } - - ast::ItemKind::TraitAlias(..) => { gate_feature_post!( &self, - trait_alias, + optin_builtin_traits, i.span, - "trait aliases are experimental" + "auto traits are experimental and possibly buggy" ); } + ast::ItemKind::TraitAlias(..) => { + gate_feature_post!(&self, trait_alias, i.span, "trait aliases are experimental"); + } + ast::ItemKind::MacroDef(ast::MacroDef { legacy: false, .. }) => { let msg = "`macro` is experimental"; gate_feature_post!(&self, decl_macro, i.span, msg); @@ -437,21 +484,23 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { fn visit_foreign_item(&mut self, i: &'a ast::ForeignItem) { match i.kind { - ast::ForeignItemKind::Fn(..) | - ast::ForeignItemKind::Static(..) => { + ast::ForeignItemKind::Fn(..) | ast::ForeignItemKind::Static(..) => { let link_name = attr::first_attr_value_str_by_name(&i.attrs, sym::link_name); let links_to_llvm = match link_name { Some(val) => val.as_str().starts_with("llvm."), - _ => false + _ => false, }; if links_to_llvm { - gate_feature_post!(&self, link_llvm_intrinsics, i.span, - "linking to LLVM intrinsics is experimental"); + gate_feature_post!( + &self, + link_llvm_intrinsics, + i.span, + "linking to LLVM intrinsics is experimental" + ); } } ast::ForeignItemKind::Ty => { - gate_feature_post!(&self, extern_types, i.span, - "extern types are experimental"); + gate_feature_post!(&self, extern_types, i.span, "extern types are experimental"); } ast::ForeignItemKind::Macro(..) => {} } @@ -465,8 +514,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { self.check_extern(bare_fn_ty.ext); } ast::TyKind::Never => { - gate_feature_post!(&self, never_type, ty.span, - "The `!` type is experimental"); + gate_feature_post!(&self, never_type, ty.span, "The `!` type is experimental"); } _ => {} } @@ -487,7 +535,9 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { match e.kind { ast::ExprKind::Box(_) => { gate_feature_post!( - &self, box_syntax, e.span, + &self, + box_syntax, + e.span, "box expression syntax is experimental; you can call `Box::new` instead" ); } @@ -495,8 +545,12 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { // To avoid noise about type ascription in common syntax errors, only emit if it // is the *only* error. if self.parse_sess.span_diagnostic.err_count() == 0 { - gate_feature_post!(&self, type_ascription, e.span, - "type ascription is experimental"); + gate_feature_post!( + &self, + type_ascription, + e.span, + "type ascription is experimental" + ); } } ast::ExprKind::TryBlock(_) => { @@ -504,8 +558,12 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { } ast::ExprKind::Block(_, opt_label) => { if let Some(label) = opt_label { - gate_feature_post!(&self, label_break_value, label.ident.span, - "labels on blocks are unstable"); + gate_feature_post!( + &self, + label_break_value, + label.ident.span, + "labels on blocks are unstable" + ); } } _ => {} @@ -537,24 +595,33 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { } } PatKind::Box(..) => { - gate_feature_post!(&self, box_patterns, - pattern.span, - "box pattern syntax is experimental"); + gate_feature_post!( + &self, + box_patterns, + pattern.span, + "box pattern syntax is experimental" + ); } PatKind::Range(_, _, Spanned { node: RangeEnd::Excluded, .. }) => { - gate_feature_post!(&self, exclusive_range_pattern, pattern.span, - "exclusive range pattern syntax is experimental"); + gate_feature_post!( + &self, + exclusive_range_pattern, + pattern.span, + "exclusive range pattern syntax is experimental" + ); } _ => {} } visit::walk_pat(self, pattern) } - fn visit_fn(&mut self, - fn_kind: FnKind<'a>, - fn_decl: &'a ast::FnDecl, - span: Span, - _node_id: NodeId) { + fn visit_fn( + &mut self, + fn_kind: FnKind<'a>, + fn_decl: &'a ast::FnDecl, + span: Span, + _node_id: NodeId, + ) { if let Some(header) = fn_kind.header() { // Stability of const fn methods are covered in // `visit_trait_item` and `visit_impl_item` below; this is @@ -571,9 +638,12 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { fn visit_generic_param(&mut self, param: &'a GenericParam) { match param.kind { - GenericParamKind::Const { .. } => - gate_feature_post!(&self, const_generics, param.ident.span, - "const generics are unstable"), + GenericParamKind::Const { .. } => gate_feature_post!( + &self, + const_generics, + param.ident.span, + "const generics are unstable" + ), _ => {} } visit::walk_generic_param(self, param) @@ -581,9 +651,12 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { fn visit_assoc_ty_constraint(&mut self, constraint: &'a AssocTyConstraint) { match constraint.kind { - AssocTyConstraintKind::Bound { .. } => - gate_feature_post!(&self, associated_type_bounds, constraint.span, - "associated type bounds are unstable"), + AssocTyConstraintKind::Bound { .. } => gate_feature_post!( + &self, + associated_type_bounds, + constraint.span, + "associated type bounds are unstable" + ), _ => {} } visit::walk_assoc_ty_constraint(self, constraint) @@ -602,7 +675,9 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { ast::AssocItemKind::TyAlias(_, ref default) => { if let Some(_) = default { gate_feature_post!( - &self, associated_type_defaults, ti.span, + &self, + associated_type_defaults, + ti.span, "associated type defaults are unstable" ); } @@ -621,7 +696,9 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { ast::AssocItemKind::Fn(ref sig, _) => { if sig.decl.c_variadic() { gate_feature_post!( - &self, c_variadic, ii.span, + &self, + c_variadic, + ii.span, "C-variadic functions are unstable" ); } @@ -639,15 +716,23 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { fn visit_vis(&mut self, vis: &'a ast::Visibility) { if let ast::VisibilityKind::Crate(ast::CrateSugar::JustCrate) = vis.node { - gate_feature_post!(&self, crate_visibility_modifier, vis.span, - "`crate` visibility modifier is experimental"); + gate_feature_post!( + &self, + crate_visibility_modifier, + vis.span, + "`crate` visibility modifier is experimental" + ); } visit::walk_vis(self, vis) } } -pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute], - crate_edition: Edition, allow_features: &Option<Vec<String>>) -> Features { +pub fn get_features( + span_handler: &Handler, + krate_attrs: &[ast::Attribute], + crate_edition: Edition, + allow_features: &Option<Vec<String>>, +) -> Features { fn feature_removed(span_handler: &Handler, span: Span, reason: Option<&str>) { let mut err = struct_span_err!(span_handler, span, E0557, "feature has been removed"); err.span_label(span, "feature has been removed"); @@ -677,7 +762,7 @@ pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute], // `edition_enabled_features` is completed before it's queried. for attr in krate_attrs { if !attr.check_name(sym::feature) { - continue + continue; } let list = match attr.meta_item_list() { @@ -710,7 +795,7 @@ pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute], for attr in krate_attrs { if !attr.check_name(sym::feature) { - continue + continue; } let list = match attr.meta_item_list() { @@ -726,17 +811,19 @@ pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute], let name = match mi.ident() { Some(ident) if mi.is_word() => ident.name, Some(ident) => { - bad_input(mi.span()).span_suggestion( - mi.span(), - "expected just one word", - format!("{}", ident.name), - Applicability::MaybeIncorrect, - ).emit(); - continue + bad_input(mi.span()) + .span_suggestion( + mi.span(), + "expected just one word", + format!("{}", ident.name), + Applicability::MaybeIncorrect, + ) + .emit(); + continue; } None => { bad_input(mi.span()).span_label(mi.span(), "expected just one word").emit(); - continue + continue; } }; @@ -748,7 +835,8 @@ pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute], "the feature `{}` is included in the Rust {} edition", name, edition, - ).emit(); + ) + .emit(); continue; } @@ -760,8 +848,8 @@ pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute], let removed = REMOVED_FEATURES.iter().find(|f| name == f.name); let stable_removed = STABLE_REMOVED_FEATURES.iter().find(|f| name == f.name); if let Some(Feature { state, .. }) = removed.or(stable_removed) { - if let FeatureState::Removed { reason } - | FeatureState::Stabilized { reason } = state + if let FeatureState::Removed { reason } | FeatureState::Stabilized { reason } = + state { feature_removed(span_handler, mi.span(), *reason); continue; @@ -776,9 +864,13 @@ pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute], if let Some(allowed) = allow_features.as_ref() { if allowed.iter().find(|&f| name.as_str() == *f).is_none() { - span_err!(span_handler, mi.span(), E0725, - "the feature `{}` is not in the list of allowed features", - name); + span_err!( + span_handler, + mi.span(), + E0725, + "the feature `{}` is not in the list of allowed features", + name + ); continue; } } @@ -796,21 +888,18 @@ pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute], features } -fn active_features_up_to(edition: Edition) -> impl Iterator<Item=&'static Feature> { - ACTIVE_FEATURES.iter() - .filter(move |feature| { - if let Some(feature_edition) = feature.edition { - feature_edition <= edition - } else { - false - } +fn active_features_up_to(edition: Edition) -> impl Iterator<Item = &'static Feature> { + ACTIVE_FEATURES.iter().filter(move |feature| { + if let Some(feature_edition) = feature.edition { feature_edition <= edition } else { false } }) } -pub fn check_crate(krate: &ast::Crate, - parse_sess: &ParseSess, - features: &Features, - unstable: UnstableFeatures) { +pub fn check_crate( + krate: &ast::Crate, + parse_sess: &ParseSess, + features: &Features, + unstable: UnstableFeatures, +) { maybe_stage_features(&parse_sess.span_diagnostic, krate, unstable); let mut visitor = PostExpansionVisitor { parse_sess, features }; @@ -820,7 +909,7 @@ pub fn check_crate(krate: &ast::Crate, for span in spans.get(&sym::$gate).unwrap_or(&vec![]) { gate_feature!(&visitor, $gate, *span, $msg); } - } + }; } gate_all!(let_chains, "`let` expressions in this position are experimental"); gate_all!(async_closure, "async closures are unstable"); @@ -840,7 +929,7 @@ pub fn check_crate(krate: &ast::Crate, gate_feature!(&visitor, $gate, *span, $msg); } } - } + }; } gate_all!(trait_alias, "trait aliases are experimental"); @@ -866,7 +955,9 @@ fn maybe_stage_features(span_handler: &Handler, krate: &ast::Crate, unstable: Un if !unstable.is_nightly_build() { for attr in krate.attrs.iter().filter(|attr| attr.check_name(sym::feature)) { span_err!( - span_handler, attr.span, E0554, + span_handler, + attr.span, + E0554, "`#![feature]` may not be used on the {} release channel", option_env!("CFG_RELEASE_CHANNEL").unwrap_or("(unknown)") ); diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 30fd23ea909..31370e2c92e 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -4,9 +4,7 @@ //! //! This API is completely unstable and subject to change. -#![doc(html_root_url = "https://doc.rust-lang.org/nightly/", - test(attr(deny(warnings))))] - +#![doc(html_root_url = "https://doc.rust-lang.org/nightly/", test(attr(deny(warnings))))] #![feature(bool_to_option)] #![feature(box_syntax)] #![feature(const_fn)] @@ -18,13 +16,12 @@ #![feature(try_trait)] #![feature(slice_patterns)] #![feature(unicode_internals)] +#![recursion_limit = "256"] -#![recursion_limit="256"] - +use ast::AttrId; pub use errors; use rustc_data_structures::sync::Lock; use rustc_index::bit_set::GrowableBitSet; -use ast::AttrId; use syntax_pos::edition::Edition; #[macro_export] @@ -34,7 +31,7 @@ macro_rules! unwrap_or { Some(x) => x, None => $default, } - } + }; } pub struct Globals { @@ -56,16 +53,16 @@ impl Globals { } pub fn with_globals<F, R>(edition: Edition, f: F) -> R - where F: FnOnce() -> R +where + F: FnOnce() -> R, { let globals = Globals::new(edition); - GLOBALS.set(&globals, || { - syntax_pos::GLOBALS.set(&globals.syntax_pos_globals, f) - }) + GLOBALS.set(&globals, || syntax_pos::GLOBALS.set(&globals.syntax_pos_globals, f)) } pub fn with_default_globals<F, R>(f: F) -> R - where F: FnOnce() -> R +where + F: FnOnce() -> R, { with_globals(edition::DEFAULT_EDITION, f) } @@ -83,9 +80,9 @@ pub mod util { pub mod comments; pub mod lev_distance; pub mod literal; + pub mod map_in_place; pub mod node_count; pub mod parser; - pub mod map_in_place; } pub mod ast; @@ -95,22 +92,22 @@ pub use syntax_pos::source_map; pub mod entry; pub mod feature_gate { mod check; - pub use check::{check_crate, check_attribute, get_features, feature_err, feature_err_issue}; + pub use check::{check_attribute, check_crate, feature_err, feature_err_issue, get_features}; } pub mod mut_visit; pub mod ptr; pub mod show_span; +pub use rustc_session::parse as sess; pub use syntax_pos::edition; pub use syntax_pos::symbol; -pub use rustc_session::parse as sess; pub mod token; pub mod tokenstream; pub mod visit; pub mod print { + mod helpers; pub mod pp; pub mod pprust; - mod helpers; } pub mod early_buffered_lints; diff --git a/src/libsyntax/mut_visit.rs b/src/libsyntax/mut_visit.rs index 1d27f70f5a5..780323d114e 100644 --- a/src/libsyntax/mut_visit.rs +++ b/src/libsyntax/mut_visit.rs @@ -8,9 +8,9 @@ //! that are created by the expansion of a macro. use crate::ast::*; -use crate::source_map::{Spanned, respan}; -use crate::token::{self, Token}; use crate::ptr::P; +use crate::source_map::{respan, Spanned}; +use crate::token::{self, Token}; use crate::tokenstream::*; use crate::util::map_in_place::MapInPlace; @@ -170,7 +170,7 @@ pub trait MutVisitor: Sized { noop_visit_foreign_mod(nm, self); } - fn flat_map_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> { + fn flat_map_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> { noop_flat_map_variant(v, self) } @@ -303,7 +303,10 @@ pub trait MutVisitor: Sized { /// method. Abort the program if the closure panics. // // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. -pub fn visit_clobber<T, F>(t: &mut T, f: F) where F: FnOnce(T) -> T { +pub fn visit_clobber<T, F>(t: &mut T, f: F) +where + F: FnOnce(T) -> T, +{ unsafe { // Safe because `t` is used in a read-only fashion by `read()` before // being overwritten by `write()`. @@ -316,7 +319,10 @@ pub fn visit_clobber<T, F>(t: &mut T, f: F) where F: FnOnce(T) -> T { // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. #[inline] -pub fn visit_vec<T, F>(elems: &mut Vec<T>, mut visit_elem: F) where F: FnMut(&mut T) { +pub fn visit_vec<T, F>(elems: &mut Vec<T>, mut visit_elem: F) +where + F: FnMut(&mut T), +{ for elem in elems { visit_elem(elem); } @@ -324,7 +330,10 @@ pub fn visit_vec<T, F>(elems: &mut Vec<T>, mut visit_elem: F) where F: FnMut(&mu // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. #[inline] -pub fn visit_opt<T, F>(opt: &mut Option<T>, mut visit_elem: F) where F: FnMut(&mut T) { +pub fn visit_opt<T, F>(opt: &mut Option<T>, mut visit_elem: F) +where + F: FnMut(&mut T), +{ if let Some(elem) = opt { visit_elem(elem); } @@ -382,15 +391,7 @@ pub fn noop_flat_map_field_pattern<T: MutVisitor>( mut fp: FieldPat, vis: &mut T, ) -> SmallVec<[FieldPat; 1]> { - let FieldPat { - attrs, - id, - ident, - is_placeholder: _, - is_shorthand: _, - pat, - span, - } = &mut fp; + let FieldPat { attrs, id, ident, is_placeholder: _, is_shorthand: _, pat, span } = &mut fp; vis.visit_id(id); vis.visit_ident(ident); vis.visit_pat(pat); @@ -432,7 +433,7 @@ pub fn noop_flat_map_arm<T: MutVisitor>(mut arm: Arm, vis: &mut T) -> SmallVec<[ pub fn noop_visit_ty_constraint<T: MutVisitor>( AssocTyConstraint { id, ident, kind, span }: &mut AssocTyConstraint, - vis: &mut T + vis: &mut T, ) { vis.visit_id(id); vis.visit_ident(ident); @@ -451,8 +452,7 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) { let Ty { id, kind, span } = ty.deref_mut(); vis.visit_id(id); match kind { - TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err | - TyKind::Never | TyKind::CVarArgs => {} + TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err | TyKind::Never | TyKind::CVarArgs => {} TyKind::Slice(ty) => vis.visit_ty(ty), TyKind::Ptr(mt) => vis.visit_mt(mt), TyKind::Rptr(lt, mt) => { @@ -475,8 +475,9 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) { vis.visit_anon_const(length); } TyKind::Typeof(expr) => vis.visit_anon_const(expr), - TyKind::TraitObject(bounds, _syntax) => - visit_vec(bounds, |bound| vis.visit_param_bound(bound)), + TyKind::TraitObject(bounds, _syntax) => { + visit_vec(bounds, |bound| vis.visit_param_bound(bound)) + } TyKind::ImplTrait(id, bounds) => { vis.visit_id(id); visit_vec(bounds, |bound| vis.visit_param_bound(bound)); @@ -487,13 +488,14 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) { } pub fn noop_visit_foreign_mod<T: MutVisitor>(foreign_mod: &mut ForeignMod, vis: &mut T) { - let ForeignMod { abi: _, items} = foreign_mod; + let ForeignMod { abi: _, items } = foreign_mod; items.flat_map_in_place(|item| vis.flat_map_foreign_item(item)); } -pub fn noop_flat_map_variant<T: MutVisitor>(mut variant: Variant, visitor: &mut T) - -> SmallVec<[Variant; 1]> -{ +pub fn noop_flat_map_variant<T: MutVisitor>( + mut variant: Variant, + visitor: &mut T, +) -> SmallVec<[Variant; 1]> { let Variant { ident, vis, attrs, id, data, disr_expr, span, is_placeholder: _ } = &mut variant; visitor.visit_ident(ident); visitor.visit_vis(vis); @@ -540,16 +542,20 @@ pub fn noop_visit_generic_arg<T: MutVisitor>(arg: &mut GenericArg, vis: &mut T) } } -pub fn noop_visit_angle_bracketed_parameter_data<T: MutVisitor>(data: &mut AngleBracketedArgs, - vis: &mut T) { +pub fn noop_visit_angle_bracketed_parameter_data<T: MutVisitor>( + data: &mut AngleBracketedArgs, + vis: &mut T, +) { let AngleBracketedArgs { args, constraints, span } = data; visit_vec(args, |arg| vis.visit_generic_arg(arg)); visit_vec(constraints, |constraint| vis.visit_ty_constraint(constraint)); vis.visit_span(span); } -pub fn noop_visit_parenthesized_parameter_data<T: MutVisitor>(args: &mut ParenthesizedArgs, - vis: &mut T) { +pub fn noop_visit_parenthesized_parameter_data<T: MutVisitor>( + args: &mut ParenthesizedArgs, + vis: &mut T, +) { let ParenthesizedArgs { inputs, output, span } = args; visit_vec(inputs, |input| vis.visit_ty(input)); noop_visit_fn_ret_ty(output, vis); @@ -681,19 +687,17 @@ pub fn noop_visit_token<T: MutVisitor>(t: &mut Token, vis: &mut T) { // multiple items there.... pub fn noop_visit_interpolated<T: MutVisitor>(nt: &mut token::Nonterminal, vis: &mut T) { match nt { - token::NtItem(item) => - visit_clobber(item, |item| { - // This is probably okay, because the only visitors likely to - // peek inside interpolated nodes will be renamings/markings, - // which map single items to single items. - vis.flat_map_item(item).expect_one("expected visitor to produce exactly one item") - }), + token::NtItem(item) => visit_clobber(item, |item| { + // This is probably okay, because the only visitors likely to + // peek inside interpolated nodes will be renamings/markings, + // which map single items to single items. + vis.flat_map_item(item).expect_one("expected visitor to produce exactly one item") + }), token::NtBlock(block) => vis.visit_block(block), - token::NtStmt(stmt) => - visit_clobber(stmt, |stmt| { - // See reasoning above. - vis.flat_map_stmt(stmt).expect_one("expected visitor to produce exactly one item") - }), + token::NtStmt(stmt) => visit_clobber(stmt, |stmt| { + // See reasoning above. + vis.flat_map_stmt(stmt).expect_one("expected visitor to produce exactly one item") + }), token::NtPat(pat) => vis.visit_pat(pat), token::NtExpr(expr) => vis.visit_expr(expr), token::NtTy(ty) => vis.visit_ty(ty), @@ -706,25 +710,20 @@ pub fn noop_visit_interpolated<T: MutVisitor>(nt: &mut token::Nonterminal, vis: } token::NtPath(path) => vis.visit_path(path), token::NtTT(tt) => vis.visit_tt(tt), - token::NtImplItem(item) => - visit_clobber(item, |item| { - // See reasoning above. - vis.flat_map_impl_item(item) - .expect_one("expected visitor to produce exactly one item") - }), - token::NtTraitItem(item) => - visit_clobber(item, |item| { - // See reasoning above. - vis.flat_map_trait_item(item) - .expect_one("expected visitor to produce exactly one item") - }), + token::NtImplItem(item) => visit_clobber(item, |item| { + // See reasoning above. + vis.flat_map_impl_item(item).expect_one("expected visitor to produce exactly one item") + }), + token::NtTraitItem(item) => visit_clobber(item, |item| { + // See reasoning above. + vis.flat_map_trait_item(item).expect_one("expected visitor to produce exactly one item") + }), token::NtVis(visib) => vis.visit_vis(visib), - token::NtForeignItem(item) => - visit_clobber(item, |item| { - // See reasoning above. - vis.flat_map_foreign_item(item) - .expect_one("expected visitor to produce exactly one item") - }), + token::NtForeignItem(item) => visit_clobber(item, |item| { + // See reasoning above. + vis.flat_map_foreign_item(item) + .expect_one("expected visitor to produce exactly one item") + }), } } @@ -760,9 +759,8 @@ pub fn noop_visit_param_bound<T: MutVisitor>(pb: &mut GenericBound, vis: &mut T) pub fn noop_flat_map_generic_param<T: MutVisitor>( mut param: GenericParam, - vis: &mut T -) -> SmallVec<[GenericParam; 1]> -{ + vis: &mut T, +) -> SmallVec<[GenericParam; 1]> { let GenericParam { id, ident, attrs, bounds, kind, is_placeholder: _ } = &mut param; vis.visit_id(id); vis.visit_ident(ident); @@ -831,11 +829,11 @@ pub fn noop_visit_variant_data<T: MutVisitor>(vdata: &mut VariantData, vis: &mut match vdata { VariantData::Struct(fields, ..) => { fields.flat_map_in_place(|field| vis.flat_map_struct_field(field)); - }, + } VariantData::Tuple(fields, id) => { fields.flat_map_in_place(|field| vis.flat_map_struct_field(field)); vis.visit_id(id); - }, + } VariantData::Unit(id) => vis.visit_id(id), } } @@ -852,9 +850,10 @@ pub fn noop_visit_poly_trait_ref<T: MutVisitor>(p: &mut PolyTraitRef, vis: &mut vis.visit_span(span); } -pub fn noop_flat_map_struct_field<T: MutVisitor>(mut sf: StructField, visitor: &mut T) - -> SmallVec<[StructField; 1]> -{ +pub fn noop_flat_map_struct_field<T: MutVisitor>( + mut sf: StructField, + visitor: &mut T, +) -> SmallVec<[StructField; 1]> { let StructField { span, ident, vis, id, ty, attrs, is_placeholder: _ } = &mut sf; visitor.visit_span(span); visit_opt(ident, |ident| visitor.visit_ident(ident)); @@ -914,8 +913,7 @@ pub fn noop_visit_item_kind<T: MutVisitor>(kind: &mut ItemKind, vis: &mut T) { variants.flat_map_in_place(|variant| vis.flat_map_variant(variant)); vis.visit_generics(generics); } - ItemKind::Struct(variant_data, generics) | - ItemKind::Union(variant_data, generics) => { + ItemKind::Struct(variant_data, generics) | ItemKind::Union(variant_data, generics) => { vis.visit_variant_data(variant_data); vis.visit_generics(generics); } @@ -939,9 +937,10 @@ pub fn noop_visit_item_kind<T: MutVisitor>(kind: &mut ItemKind, vis: &mut T) { } } -pub fn noop_flat_map_assoc_item<T: MutVisitor>(mut item: AssocItem, visitor: &mut T) - -> SmallVec<[AssocItem; 1]> -{ +pub fn noop_flat_map_assoc_item<T: MutVisitor>( + mut item: AssocItem, + visitor: &mut T, +) -> SmallVec<[AssocItem; 1]> { let AssocItem { id, ident, vis, defaultness: _, attrs, generics, kind, span, tokens: _ } = &mut item; visitor.visit_id(id); @@ -949,7 +948,7 @@ pub fn noop_flat_map_assoc_item<T: MutVisitor>(mut item: AssocItem, visitor: &mu visitor.visit_vis(vis); visit_attrs(attrs, visitor); visitor.visit_generics(generics); - match kind { + match kind { AssocItemKind::Const(ty, expr) => { visitor.visit_ty(ty); visit_opt(expr, |expr| visitor.visit_expr(expr)); @@ -1009,8 +1008,10 @@ pub fn noop_visit_crate<T: MutVisitor>(krate: &mut Crate, vis: &mut T) { } // Mutates one item into possibly many items. -pub fn noop_flat_map_item<T: MutVisitor>(mut item: P<Item>, visitor: &mut T) - -> SmallVec<[P<Item>; 1]> { +pub fn noop_flat_map_item<T: MutVisitor>( + mut item: P<Item>, + visitor: &mut T, +) -> SmallVec<[P<Item>; 1]> { let Item { ident, attrs, id, kind, vis, span, tokens: _ } = item.deref_mut(); visitor.visit_ident(ident); visit_attrs(attrs, visitor); @@ -1025,9 +1026,10 @@ pub fn noop_flat_map_item<T: MutVisitor>(mut item: P<Item>, visitor: &mut T) smallvec![item] } -pub fn noop_flat_map_foreign_item<T: MutVisitor>(mut item: ForeignItem, visitor: &mut T) - -> SmallVec<[ForeignItem; 1]> -{ +pub fn noop_flat_map_foreign_item<T: MutVisitor>( + mut item: ForeignItem, + visitor: &mut T, +) -> SmallVec<[ForeignItem; 1]> { let ForeignItem { ident, attrs, id, kind, vis, span, tokens: _ } = &mut item; visitor.visit_ident(ident); visit_attrs(attrs, visitor); @@ -1076,9 +1078,9 @@ pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) { vis.visit_expr(e2); vis.visit_span(span); } - PatKind::Tuple(elems) - | PatKind::Slice(elems) - | PatKind::Or(elems) => visit_vec(elems, |elem| vis.visit_pat(elem)), + PatKind::Tuple(elems) | PatKind::Slice(elems) | PatKind::Or(elems) => { + visit_vec(elems, |elem| vis.visit_pat(elem)) + } PatKind::Paren(inner) => vis.visit_pat(inner), PatKind::Mac(mac) => vis.visit_mac(mac), } @@ -1201,8 +1203,16 @@ pub fn noop_visit_expr<T: MutVisitor>(Expr { kind, id, span, attrs }: &mut Expr, visit_opt(expr, |expr| vis.visit_expr(expr)); } ExprKind::InlineAsm(asm) => { - let InlineAsm { asm: _, asm_str_style: _, outputs, inputs, clobbers: _, volatile: _, - alignstack: _, dialect: _ } = asm.deref_mut(); + let InlineAsm { + asm: _, + asm_str_style: _, + outputs, + inputs, + clobbers: _, + volatile: _, + alignstack: _, + dialect: _, + } = asm.deref_mut(); for out in outputs { let InlineAsmOutput { constraint: _, expr, is_rw: _, is_indirect: _ } = out; vis.visit_expr(expr); @@ -1214,7 +1224,7 @@ pub fn noop_visit_expr<T: MutVisitor>(Expr { kind, id, span, attrs }: &mut Expr, vis.visit_path(path); fields.flat_map_in_place(|field| vis.flat_map_field(field)); visit_opt(expr, |expr| vis.visit_expr(expr)); - }, + } ExprKind::Paren(expr) => { vis.visit_expr(expr); @@ -1237,31 +1247,33 @@ pub fn noop_visit_expr<T: MutVisitor>(Expr { kind, id, span, attrs }: &mut Expr, } pub fn noop_filter_map_expr<T: MutVisitor>(mut e: P<Expr>, vis: &mut T) -> Option<P<Expr>> { - Some({ vis.visit_expr(&mut e); e }) + Some({ + vis.visit_expr(&mut e); + e + }) } -pub fn noop_flat_map_stmt<T: MutVisitor>(Stmt { kind, mut span, mut id }: Stmt, vis: &mut T) - -> SmallVec<[Stmt; 1]> -{ +pub fn noop_flat_map_stmt<T: MutVisitor>( + Stmt { kind, mut span, mut id }: Stmt, + vis: &mut T, +) -> SmallVec<[Stmt; 1]> { vis.visit_id(&mut id); vis.visit_span(&mut span); - noop_flat_map_stmt_kind(kind, vis).into_iter().map(|kind| { - Stmt { id, kind, span } - }).collect() + noop_flat_map_stmt_kind(kind, vis).into_iter().map(|kind| Stmt { id, kind, span }).collect() } -pub fn noop_flat_map_stmt_kind<T: MutVisitor>(kind: StmtKind, vis: &mut T) - -> SmallVec<[StmtKind; 1]> { +pub fn noop_flat_map_stmt_kind<T: MutVisitor>( + kind: StmtKind, + vis: &mut T, +) -> SmallVec<[StmtKind; 1]> { match kind { - StmtKind::Local(mut local) => - smallvec![StmtKind::Local({ vis.visit_local(&mut local); local })], + StmtKind::Local(mut local) => smallvec![StmtKind::Local({ + vis.visit_local(&mut local); + local + })], StmtKind::Item(item) => vis.flat_map_item(item).into_iter().map(StmtKind::Item).collect(), - StmtKind::Expr(expr) => { - vis.filter_map_expr(expr).into_iter().map(StmtKind::Expr).collect() - } - StmtKind::Semi(expr) => { - vis.filter_map_expr(expr).into_iter().map(StmtKind::Semi).collect() - } + StmtKind::Expr(expr) => vis.filter_map_expr(expr).into_iter().map(StmtKind::Expr).collect(), + StmtKind::Semi(expr) => vis.filter_map_expr(expr).into_iter().map(StmtKind::Semi).collect(), StmtKind::Mac(mut mac) => { let (mac_, _semi, attrs) = mac.deref_mut(); vis.visit_mac(mac_); diff --git a/src/libsyntax/print/helpers.rs b/src/libsyntax/print/helpers.rs index 3449e07f456..88942cb7fd6 100644 --- a/src/libsyntax/print/helpers.rs +++ b/src/libsyntax/print/helpers.rs @@ -1,5 +1,5 @@ -use std::borrow::Cow; use crate::print::pp::Printer; +use std::borrow::Cow; impl Printer { pub fn word_space<W: Into<Cow<'static, str>>>(&mut self, w: W) { @@ -22,10 +22,14 @@ impl Printer { } pub fn space_if_not_bol(&mut self) { - if !self.is_beginning_of_line() { self.space(); } + if !self.is_beginning_of_line() { + self.space(); + } } - pub fn nbsp(&mut self) { self.word(" ") } + pub fn nbsp(&mut self) { + self.word(" ") + } pub fn word_nbsp<S: Into<Cow<'static, str>>>(&mut self, w: S) { self.word(w); diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index 660e77f77d0..e6090db3284 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -134,10 +134,10 @@ //! methods called `Printer::scan_*`, and the 'PRINT' process is the //! method called `Printer::print`. +use log::debug; +use std::borrow::Cow; use std::collections::VecDeque; use std::fmt; -use std::borrow::Cow; -use log::debug; /// How to break. Described in more detail in the module docs. #[derive(Clone, Copy, PartialEq)] @@ -149,13 +149,13 @@ pub enum Breaks { #[derive(Clone, Copy)] pub struct BreakToken { offset: isize, - blank_space: isize + blank_space: isize, } #[derive(Clone, Copy)] pub struct BeginToken { offset: isize, - breaks: Breaks + breaks: Breaks, } #[derive(Clone)] @@ -180,13 +180,8 @@ impl Token { pub fn is_hardbreak_tok(&self) -> bool { match *self { - Token::Break(BreakToken { - offset: 0, - blank_space: bs - }) if bs == SIZE_INFINITY => - true, - _ => - false + Token::Break(BreakToken { offset: 0, blank_space: bs }) if bs == SIZE_INFINITY => true, + _ => false, } } } @@ -230,7 +225,7 @@ enum PrintStackBreak { #[derive(Copy, Clone)] struct PrintStackElem { offset: isize, - pbreak: PrintStackBreak + pbreak: PrintStackBreak, } const SIZE_INFINITY: isize = 0xffff; @@ -254,7 +249,7 @@ pub fn mk_printer() -> Printer { right_total: 0, scan_stack: VecDeque::new(), print_stack: Vec::new(), - pending_indentation: 0 + pending_indentation: 0, } } @@ -283,7 +278,7 @@ pub struct Printer { /// advancing. scan_stack: VecDeque<usize>, /// Stack of blocks-in-progress being flushed by print - print_stack: Vec<PrintStackElem> , + print_stack: Vec<PrintStackElem>, /// Buffered indentation to avoid writing trailing whitespace pending_indentation: isize, } @@ -326,8 +321,7 @@ impl Printer { } else { self.advance_right(); } - debug!("pp Begin({})/buffer Vec<{},{}>", - b.offset, self.left, self.right); + debug!("pp Begin({})/buffer Vec<{},{}>", b.offset, self.left, self.right); self.scan_push(BufEntry { token: Token::Begin(b), size: -self.right_total }); } @@ -351,8 +345,7 @@ impl Printer { } else { self.advance_right(); } - debug!("pp Break({})/buffer Vec<{},{}>", - b.offset, self.left, self.right); + debug!("pp Break({})/buffer Vec<{},{}>", b.offset, self.left, self.right); self.check_stack(0); self.scan_push(BufEntry { token: Token::Break(b), size: -self.right_total }); self.right_total += b.blank_space; @@ -360,12 +353,10 @@ impl Printer { fn scan_string(&mut self, s: Cow<'static, str>) { if self.scan_stack.is_empty() { - debug!("pp String('{}')/print Vec<{},{}>", - s, self.left, self.right); + debug!("pp String('{}')/print Vec<{},{}>", s, self.left, self.right); self.print_string(s); } else { - debug!("pp String('{}')/buffer Vec<{},{}>", - s, self.left, self.right); + debug!("pp String('{}')/buffer Vec<{},{}>", s, self.left, self.right); self.advance_right(); let len = s.len() as isize; self.buf[self.right] = BufEntry { token: Token::String(s), size: len }; @@ -375,11 +366,16 @@ impl Printer { } fn check_stream(&mut self) { - debug!("check_stream Vec<{}, {}> with left_total={}, right_total={}", - self.left, self.right, self.left_total, self.right_total); + debug!( + "check_stream Vec<{}, {}> with left_total={}, right_total={}", + self.left, self.right, self.left_total, self.right_total + ); if self.right_total - self.left_total > self.space { - debug!("scan window is {}, longer than space on line ({})", - self.right_total - self.left_total, self.space); + debug!( + "scan window is {}, longer than space on line ({})", + self.right_total - self.left_total, + self.space + ); if Some(&self.left) == self.scan_stack.back() { debug!("setting {} to infinity and popping", self.left); let scanned = self.scan_pop_bottom(); @@ -421,8 +417,10 @@ impl Printer { } fn advance_left(&mut self) { - debug!("advance_left Vec<{},{}>, sizeof({})={}", self.left, self.right, - self.left, self.buf[self.left].size); + debug!( + "advance_left Vec<{},{}>, sizeof({})={}", + self.left, self.right, self.left, self.buf[self.left].size + ); let mut left_size = self.buf[self.left].size; @@ -436,7 +434,7 @@ impl Printer { assert_eq!(len, left_size); len } - _ => 0 + _ => 0, }; self.print(left, left_size); @@ -497,9 +495,8 @@ impl Printer { fn get_top(&mut self) -> PrintStackElem { match self.print_stack.last() { Some(el) => *el, - None => PrintStackElem { - offset: 0, - pbreak: PrintStackBreak::Broken(Breaks::Inconsistent) + None => { + PrintStackElem { offset: 0, pbreak: PrintStackBreak::Broken(Breaks::Inconsistent) } } } } @@ -508,16 +505,11 @@ impl Printer { if l > self.space { let col = self.margin - self.space + b.offset; debug!("print Begin -> push broken block at col {}", col); - self.print_stack.push(PrintStackElem { - offset: col, - pbreak: PrintStackBreak::Broken(b.breaks) - }); + self.print_stack + .push(PrintStackElem { offset: col, pbreak: PrintStackBreak::Broken(b.breaks) }); } else { debug!("print Begin -> push fitting block"); - self.print_stack.push(PrintStackElem { - offset: 0, - pbreak: PrintStackBreak::Fits - }); + self.print_stack.push(PrintStackElem { offset: 0, pbreak: PrintStackBreak::Fits }); } } @@ -535,20 +527,17 @@ impl Printer { self.indent(b.blank_space); } PrintStackBreak::Broken(Breaks::Consistent) => { - debug!("print Break({}+{}) in consistent block", - top.offset, b.offset); + debug!("print Break({}+{}) in consistent block", top.offset, b.offset); self.print_newline(top.offset + b.offset); self.space = self.margin - (top.offset + b.offset); } PrintStackBreak::Broken(Breaks::Inconsistent) => { if l > self.space { - debug!("print Break({}+{}) w/ newline in inconsistent", - top.offset, b.offset); + debug!("print Break({}+{}) w/ newline in inconsistent", top.offset, b.offset); self.print_newline(top.offset + b.offset); self.space = self.margin - (top.offset + b.offset); } else { - debug!("print Break({}) w/o newline in inconsistent", - b.blank_space); + debug!("print Break({}) w/o newline in inconsistent", b.blank_space); self.indent(b.blank_space); self.space -= b.blank_space; } @@ -575,12 +564,8 @@ impl Printer { } fn print(&mut self, token: Token, l: isize) { - debug!("print {} {} (remaining line space={})", token, l, - self.space); - debug!("{}", buf_str(&self.buf, - self.left, - self.right, - 6)); + debug!("print {} {} (remaining line space={})", token, l, self.space); + debug!("{}", buf_str(&self.buf, self.left, self.right, 6)); match token { Token::Begin(b) => self.print_begin(b, l), Token::End => self.print_end(), @@ -598,10 +583,7 @@ impl Printer { /// "raw box" pub fn rbox(&mut self, indent: usize, b: Breaks) { - self.scan_begin(BeginToken { - offset: indent as isize, - breaks: b - }) + self.scan_begin(BeginToken { offset: indent as isize, breaks: b }) } /// Inconsistent breaking box @@ -615,10 +597,7 @@ impl Printer { } pub fn break_offset(&mut self, n: usize, off: isize) { - self.scan_break(BreakToken { - offset: off, - blank_space: n as isize - }) + self.scan_break(BreakToken { offset: off, blank_space: n as isize }) } pub fn end(&mut self) { @@ -656,6 +635,6 @@ impl Printer { } pub fn hardbreak_tok_offset(off: isize) -> Token { - Token::Break(BreakToken {offset: off, blank_space: SIZE_INFINITY}) + Token::Break(BreakToken { offset: off, blank_space: SIZE_INFINITY }) } } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index e63d11ce832..dc01f2472b7 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1,18 +1,18 @@ use crate::ast::{self, BlockCheckMode, PatKind, RangeEnd, RangeSyntax}; -use crate::ast::{SelfKind, GenericBound, TraitBoundModifier}; use crate::ast::{Attribute, GenericArg, MacArgs}; -use crate::util::parser::{self, AssocOp, Fixity}; -use crate::util::comments; +use crate::ast::{GenericBound, SelfKind, TraitBoundModifier}; use crate::attr; -use crate::source_map::{self, SourceMap, Spanned}; -use crate::token::{self, BinOpToken, DelimToken, Nonterminal, Token, TokenKind}; -use crate::print::pp::{self, Breaks}; use crate::print::pp::Breaks::{Consistent, Inconsistent}; +use crate::print::pp::{self, Breaks}; use crate::ptr::P; -use crate::util::classify; use crate::sess::ParseSess; +use crate::source_map::{self, SourceMap, Spanned}; use crate::symbol::{kw, sym}; +use crate::token::{self, BinOpToken, DelimToken, Nonterminal, Token, TokenKind}; use crate::tokenstream::{self, TokenStream, TokenTree}; +use crate::util::classify; +use crate::util::comments; +use crate::util::parser::{self, AssocOp, Fixity}; use syntax_pos::{self, BytePos}; use syntax_pos::{FileName, Span}; @@ -39,8 +39,8 @@ pub enum AnnNode<'a> { } pub trait PpAnn { - fn pre(&self, _state: &mut State<'_>, _node: AnnNode<'_>) { } - fn post(&self, _state: &mut State<'_>, _node: AnnNode<'_>) { } + fn pre(&self, _state: &mut State<'_>, _node: AnnNode<'_>) {} + fn post(&self, _state: &mut State<'_>, _node: AnnNode<'_>) {} } #[derive(Copy, Clone)] @@ -62,11 +62,7 @@ impl<'a> Comments<'a> { input: String, ) -> Comments<'a> { let comments = comments::gather_comments(sess, filename, input); - Comments { - cm, - comments, - current: 0, - } + Comments { cm, comments, current: 0 } } pub fn next(&self) -> Option<comments::Comment> { @@ -79,7 +75,9 @@ impl<'a> Comments<'a> { next_pos: Option<BytePos>, ) -> Option<comments::Comment> { if let Some(cmnt) = self.next() { - if cmnt.style != comments::Trailing { return None; } + if cmnt.style != comments::Trailing { + return None; + } let span_line = self.cm.lookup_char_pos(span.hi()); let comment_line = self.cm.lookup_char_pos(cmnt.pos); let next = next_pos.unwrap_or_else(|| cmnt.pos + BytePos(1)); @@ -95,21 +93,23 @@ impl<'a> Comments<'a> { pub struct State<'a> { pub s: pp::Printer, comments: Option<Comments<'a>>, - ann: &'a (dyn PpAnn+'a), - is_expanded: bool + ann: &'a (dyn PpAnn + 'a), + is_expanded: bool, } crate const INDENT_UNIT: usize = 4; /// Requires you to pass an input filename and reader so that /// it can scan the input text for comments to copy forward. -pub fn print_crate<'a>(cm: &'a SourceMap, - sess: &ParseSess, - krate: &ast::Crate, - filename: FileName, - input: String, - ann: &'a dyn PpAnn, - is_expanded: bool) -> String { +pub fn print_crate<'a>( + cm: &'a SourceMap, + sess: &ParseSess, + krate: &ast::Crate, + filename: FileName, + input: String, + ann: &'a dyn PpAnn, + is_expanded: bool, +) -> String { let mut s = State { s: pp::mk_printer(), comments: Some(Comments::new(cm, sess, filename, input)), @@ -145,15 +145,12 @@ pub fn print_crate<'a>(cm: &'a SourceMap, s.s.eof() } -pub fn to_string<F>(f: F) -> String where +pub fn to_string<F>(f: F) -> String +where F: FnOnce(&mut State<'_>), { - let mut printer = State { - s: pp::mk_printer(), - comments: None, - ann: &NoAnn, - is_expanded: false - }; + let mut printer = + State { s: pp::mk_printer(), comments: None, ann: &NoAnn, is_expanded: false }; f(&mut printer); printer.s.eof() } @@ -165,43 +162,40 @@ fn tt_prepend_space(tt: &TokenTree) -> bool { TokenTree::Token(token) => match token.kind { token::Comma => false, _ => true, - } + }, _ => true, } } fn binop_to_string(op: BinOpToken) -> &'static str { match op { - token::Plus => "+", - token::Minus => "-", - token::Star => "*", - token::Slash => "/", - token::Percent => "%", - token::Caret => "^", - token::And => "&", - token::Or => "|", - token::Shl => "<<", - token::Shr => ">>", + token::Plus => "+", + token::Minus => "-", + token::Star => "*", + token::Slash => "/", + token::Percent => "%", + token::Caret => "^", + token::And => "&", + token::Or => "|", + token::Shl => "<<", + token::Shr => ">>", } } pub fn literal_to_string(lit: token::Lit) -> String { let token::Lit { kind, symbol, suffix } = lit; let mut out = match kind { - token::Byte => format!("b'{}'", symbol), - token::Char => format!("'{}'", symbol), - token::Str => format!("\"{}\"", symbol), - token::StrRaw(n) => format!("r{delim}\"{string}\"{delim}", - delim="#".repeat(n as usize), - string=symbol), - token::ByteStr => format!("b\"{}\"", symbol), - token::ByteStrRaw(n) => format!("br{delim}\"{string}\"{delim}", - delim="#".repeat(n as usize), - string=symbol), - token::Integer | - token::Float | - token::Bool | - token::Err => symbol.to_string(), + token::Byte => format!("b'{}'", symbol), + token::Char => format!("'{}'", symbol), + token::Str => format!("\"{}\"", symbol), + token::StrRaw(n) => { + format!("r{delim}\"{string}\"{delim}", delim = "#".repeat(n as usize), string = symbol) + } + token::ByteStr => format!("b\"{}\"", symbol), + token::ByteStrRaw(n) => { + format!("br{delim}\"{string}\"{delim}", delim = "#".repeat(n as usize), string = symbol) + } + token::Integer | token::Float | token::Bool | token::Err => symbol.to_string(), }; if let Some(suffix) = suffix { @@ -238,7 +232,7 @@ fn ident_to_string(name: ast::Name, is_raw: bool, convert_dollar_crate: Option<S converted.to_string() } else { format!("::{}", converted) - } + }; } } name.to_string() @@ -252,60 +246,59 @@ pub fn token_kind_to_string(tok: &TokenKind) -> String { fn token_kind_to_string_ext(tok: &TokenKind, convert_dollar_crate: Option<Span>) -> String { match *tok { - token::Eq => "=".to_string(), - token::Lt => "<".to_string(), - token::Le => "<=".to_string(), - token::EqEq => "==".to_string(), - token::Ne => "!=".to_string(), - token::Ge => ">=".to_string(), - token::Gt => ">".to_string(), - token::Not => "!".to_string(), - token::Tilde => "~".to_string(), - token::OrOr => "||".to_string(), - token::AndAnd => "&&".to_string(), - token::BinOp(op) => binop_to_string(op).to_string(), - token::BinOpEq(op) => format!("{}=", binop_to_string(op)), + token::Eq => "=".to_string(), + token::Lt => "<".to_string(), + token::Le => "<=".to_string(), + token::EqEq => "==".to_string(), + token::Ne => "!=".to_string(), + token::Ge => ">=".to_string(), + token::Gt => ">".to_string(), + token::Not => "!".to_string(), + token::Tilde => "~".to_string(), + token::OrOr => "||".to_string(), + token::AndAnd => "&&".to_string(), + token::BinOp(op) => binop_to_string(op).to_string(), + token::BinOpEq(op) => format!("{}=", binop_to_string(op)), /* Structural symbols */ - token::At => "@".to_string(), - token::Dot => ".".to_string(), - token::DotDot => "..".to_string(), - token::DotDotDot => "...".to_string(), - token::DotDotEq => "..=".to_string(), - token::Comma => ",".to_string(), - token::Semi => ";".to_string(), - token::Colon => ":".to_string(), - token::ModSep => "::".to_string(), - token::RArrow => "->".to_string(), - token::LArrow => "<-".to_string(), - token::FatArrow => "=>".to_string(), + token::At => "@".to_string(), + token::Dot => ".".to_string(), + token::DotDot => "..".to_string(), + token::DotDotDot => "...".to_string(), + token::DotDotEq => "..=".to_string(), + token::Comma => ",".to_string(), + token::Semi => ";".to_string(), + token::Colon => ":".to_string(), + token::ModSep => "::".to_string(), + token::RArrow => "->".to_string(), + token::LArrow => "<-".to_string(), + token::FatArrow => "=>".to_string(), token::OpenDelim(token::Paren) => "(".to_string(), token::CloseDelim(token::Paren) => ")".to_string(), token::OpenDelim(token::Bracket) => "[".to_string(), token::CloseDelim(token::Bracket) => "]".to_string(), token::OpenDelim(token::Brace) => "{".to_string(), token::CloseDelim(token::Brace) => "}".to_string(), - token::OpenDelim(token::NoDelim) | - token::CloseDelim(token::NoDelim) => " ".to_string(), - token::Pound => "#".to_string(), - token::Dollar => "$".to_string(), - token::Question => "?".to_string(), - token::SingleQuote => "'".to_string(), + token::OpenDelim(token::NoDelim) | token::CloseDelim(token::NoDelim) => " ".to_string(), + token::Pound => "#".to_string(), + token::Dollar => "$".to_string(), + token::Question => "?".to_string(), + token::SingleQuote => "'".to_string(), /* Literals */ token::Literal(lit) => literal_to_string(lit), /* Name components */ - token::Ident(s, is_raw) => ident_to_string(s, is_raw, convert_dollar_crate), - token::Lifetime(s) => s.to_string(), + token::Ident(s, is_raw) => ident_to_string(s, is_raw, convert_dollar_crate), + token::Lifetime(s) => s.to_string(), /* Other */ - token::DocComment(s) => s.to_string(), - token::Eof => "<eof>".to_string(), - token::Whitespace => " ".to_string(), - token::Comment => "/* */".to_string(), - token::Shebang(s) => format!("/* shebang: {}*/", s), - token::Unknown(s) => s.to_string(), + token::DocComment(s) => s.to_string(), + token::Eof => "<eof>".to_string(), + token::Whitespace => " ".to_string(), + token::Comment => "/* */".to_string(), + token::Shebang(s) => format!("/* shebang: {}*/", s), + token::Unknown(s) => s.to_string(), token::Interpolated(ref nt) => nonterminal_to_string(nt), } @@ -323,21 +316,21 @@ fn token_to_string_ext(token: &Token, convert_dollar_crate: bool) -> String { pub fn nonterminal_to_string(nt: &Nonterminal) -> String { match *nt { - token::NtExpr(ref e) => expr_to_string(e), - token::NtMeta(ref e) => attr_item_to_string(e), - token::NtTy(ref e) => ty_to_string(e), - token::NtPath(ref e) => path_to_string(e), - token::NtItem(ref e) => item_to_string(e), - token::NtBlock(ref e) => block_to_string(e), - token::NtStmt(ref e) => stmt_to_string(e), - token::NtPat(ref e) => pat_to_string(e), - token::NtIdent(e, is_raw) => ast_ident_to_string(e, is_raw), - token::NtLifetime(e) => e.to_string(), - token::NtLiteral(ref e) => expr_to_string(e), - token::NtTT(ref tree) => tt_to_string(tree.clone()), + token::NtExpr(ref e) => expr_to_string(e), + token::NtMeta(ref e) => attr_item_to_string(e), + token::NtTy(ref e) => ty_to_string(e), + token::NtPath(ref e) => path_to_string(e), + token::NtItem(ref e) => item_to_string(e), + token::NtBlock(ref e) => block_to_string(e), + token::NtStmt(ref e) => stmt_to_string(e), + token::NtPat(ref e) => pat_to_string(e), + token::NtIdent(e, is_raw) => ast_ident_to_string(e, is_raw), + token::NtLifetime(e) => e.to_string(), + token::NtLiteral(ref e) => expr_to_string(e), + token::NtTT(ref tree) => tt_to_string(tree.clone()), // FIXME(Centril): merge these variants. token::NtImplItem(ref e) | token::NtTraitItem(ref e) => assoc_item_to_string(e), - token::NtVis(ref e) => vis_to_string(e), + token::NtVis(ref e) => vis_to_string(e), token::NtForeignItem(ref e) => foreign_item_to_string(e), } } @@ -446,9 +439,15 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere fn print_ident(&mut self, ident: ast::Ident); fn print_generic_args(&mut self, args: &ast::GenericArgs, colons_before_params: bool); - fn strsep<T, F>(&mut self, sep: &'static str, space_before: bool, - b: Breaks, elts: &[T], mut op: F) - where F: FnMut(&mut Self, &T), + fn strsep<T, F>( + &mut self, + sep: &'static str, + space_before: bool, + b: Breaks, + elts: &[T], + mut op: F, + ) where + F: FnMut(&mut Self, &T), { self.rbox(0, b); if let Some((first, rest)) = elts.split_first() { @@ -465,7 +464,8 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere } fn commasep<T, F>(&mut self, b: Breaks, elts: &[T], op: F) - where F: FnMut(&mut Self, &T), + where + F: FnMut(&mut Self, &T), { self.strsep(",", false, b, elts, op) } @@ -475,13 +475,12 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere if cmnt.pos < pos { self.print_comment(cmnt); } else { - break + break; } } } - fn print_comment(&mut self, - cmnt: &comments::Comment) { + fn print_comment(&mut self, cmnt: &comments::Comment) { match cmnt.style { comments::Mixed => { assert_eq!(cmnt.lines.len(), 1); @@ -524,7 +523,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere pp::Token::String(s) => ";" == s, pp::Token::Begin(_) => true, pp::Token::End => true, - _ => false + _ => false, }; if twice { self.hardbreak(); @@ -546,52 +545,47 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere self.word(lit.token.to_string()) } - fn print_string(&mut self, st: &str, - style: ast::StrStyle) { + fn print_string(&mut self, st: &str, style: ast::StrStyle) { let st = match style { - ast::StrStyle::Cooked => { - (format!("\"{}\"", st.escape_debug())) - } + ast::StrStyle::Cooked => (format!("\"{}\"", st.escape_debug())), ast::StrStyle::Raw(n) => { - (format!("r{delim}\"{string}\"{delim}", - delim="#".repeat(n as usize), - string=st)) + (format!( + "r{delim}\"{string}\"{delim}", + delim = "#".repeat(n as usize), + string = st + )) } }; self.word(st) } - fn print_inner_attributes(&mut self, - attrs: &[ast::Attribute]) { + fn print_inner_attributes(&mut self, attrs: &[ast::Attribute]) { self.print_either_attributes(attrs, ast::AttrStyle::Inner, false, true) } - fn print_inner_attributes_no_trailing_hardbreak(&mut self, - attrs: &[ast::Attribute]) - { + fn print_inner_attributes_no_trailing_hardbreak(&mut self, attrs: &[ast::Attribute]) { self.print_either_attributes(attrs, ast::AttrStyle::Inner, false, false) } - fn print_outer_attributes(&mut self, - attrs: &[ast::Attribute]) { + fn print_outer_attributes(&mut self, attrs: &[ast::Attribute]) { self.print_either_attributes(attrs, ast::AttrStyle::Outer, false, true) } - fn print_inner_attributes_inline(&mut self, - attrs: &[ast::Attribute]) { + fn print_inner_attributes_inline(&mut self, attrs: &[ast::Attribute]) { self.print_either_attributes(attrs, ast::AttrStyle::Inner, true, true) } - fn print_outer_attributes_inline(&mut self, - attrs: &[ast::Attribute]) { + fn print_outer_attributes_inline(&mut self, attrs: &[ast::Attribute]) { self.print_either_attributes(attrs, ast::AttrStyle::Outer, true, true) } - fn print_either_attributes(&mut self, - attrs: &[ast::Attribute], - kind: ast::AttrStyle, - is_inline: bool, - trailing_hardbreak: bool) { + fn print_either_attributes( + &mut self, + attrs: &[ast::Attribute], + kind: ast::AttrStyle, + is_inline: bool, + trailing_hardbreak: bool, + ) { let mut count = 0; for attr in attrs { if attr.style == kind { @@ -611,8 +605,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere self.print_attribute_inline(attr, false) } - fn print_attribute_inline(&mut self, attr: &ast::Attribute, - is_inline: bool) { + fn print_attribute_inline(&mut self, attr: &ast::Attribute, is_inline: bool) { if !is_inline { self.hardbreak_if_not_bol(); } @@ -659,12 +652,8 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere fn print_meta_list_item(&mut self, item: &ast::NestedMetaItem) { match item { - ast::NestedMetaItem::MetaItem(ref mi) => { - self.print_meta_item(mi) - }, - ast::NestedMetaItem::Literal(ref lit) => { - self.print_literal(lit) - } + ast::NestedMetaItem::MetaItem(ref mi) => self.print_meta_item(mi), + ast::NestedMetaItem::Literal(ref lit) => self.print_literal(lit), } } @@ -681,9 +670,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere ast::MetaItemKind::List(ref items) => { self.print_path(&item.path, false, 0); self.popen(); - self.commasep(Consistent, - &items[..], - |s, i| s.print_meta_list_item(i)); + self.commasep(Consistent, &items[..], |s, i| s.print_meta_list_item(i)); self.pclose(); } } @@ -702,15 +689,19 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere TokenTree::Token(ref token) => { self.word(token_to_string_ext(&token, convert_dollar_crate)); match token.kind { - token::DocComment(..) => { - self.hardbreak() - } + token::DocComment(..) => self.hardbreak(), _ => {} } } TokenTree::Delimited(dspan, delim, tts) => { self.print_mac_common( - None, false, None, delim, tts, convert_dollar_crate, dspan.entire() + None, + false, + None, + delim, + tts, + convert_dollar_crate, + dspan.entire(), ); } } @@ -902,11 +893,8 @@ impl<'a> State<'a> { self.s.word("*/") } - crate fn commasep_cmnt<T, F, G>(&mut self, - b: Breaks, - elts: &[T], - mut op: F, - mut get_span: G) where + crate fn commasep_cmnt<T, F, G>(&mut self, b: Breaks, elts: &[T], mut op: F, mut get_span: G) + where F: FnMut(&mut State<'_>, &T), G: FnMut(&T) -> syntax_pos::Span, { @@ -919,32 +907,25 @@ impl<'a> State<'a> { i += 1; if i < len { self.s.word(","); - self.maybe_print_trailing_comment(get_span(elt), - Some(get_span(&elts[i]).hi())); + self.maybe_print_trailing_comment(get_span(elt), Some(get_span(&elts[i]).hi())); self.space_if_not_bol(); } } self.end(); } - crate fn commasep_exprs(&mut self, b: Breaks, - exprs: &[P<ast::Expr>]) { + crate fn commasep_exprs(&mut self, b: Breaks, exprs: &[P<ast::Expr>]) { self.commasep_cmnt(b, exprs, |s, e| s.print_expr(e), |e| e.span) } - pub fn print_mod( - &mut self, - _mod: &ast::Mod, - attrs: &[ast::Attribute], - ) { + pub fn print_mod(&mut self, _mod: &ast::Mod, attrs: &[ast::Attribute]) { self.print_inner_attributes(attrs); for item in &_mod.items { self.print_item(item); } } - crate fn print_foreign_mod(&mut self, nmod: &ast::ForeignMod, - attrs: &[ast::Attribute]) { + crate fn print_foreign_mod(&mut self, nmod: &ast::ForeignMod, attrs: &[ast::Attribute]) { self.print_inner_attributes(attrs); for item in &nmod.items { self.print_foreign_item(item); @@ -986,11 +967,10 @@ impl<'a> State<'a> { } ast::TyKind::Never => { self.s.word("!"); - }, + } ast::TyKind::Tup(ref elts) => { self.popen(); - self.commasep(Inconsistent, &elts[..], - |s, ty| s.print_type(ty)); + self.commasep(Inconsistent, &elts[..], |s, ty| s.print_type(ty)); if elts.len() == 1 { self.s.word(","); } @@ -1002,18 +982,12 @@ impl<'a> State<'a> { self.pclose(); } ast::TyKind::BareFn(ref f) => { - self.print_ty_fn(f.ext, - f.unsafety, - &f.decl, - None, - &f.generic_params); + self.print_ty_fn(f.ext, f.unsafety, &f.decl, None, &f.generic_params); } ast::TyKind::Path(None, ref path) => { self.print_path(path, false, 0); } - ast::TyKind::Path(Some(ref qself), ref path) => { - self.print_qpath(path, qself, false) - } + ast::TyKind::Path(Some(ref qself), ref path) => self.print_qpath(path, qself, false), ast::TyKind::TraitObject(ref bounds, syntax) => { let prefix = if syntax == ast::TraitObjectSyntax::Dyn { "dyn" } else { "" }; self.print_type_bounds(prefix, &bounds[..]); @@ -1054,17 +1028,20 @@ impl<'a> State<'a> { self.end(); } - crate fn print_foreign_item(&mut self, - item: &ast::ForeignItem) { + crate fn print_foreign_item(&mut self, item: &ast::ForeignItem) { self.hardbreak_if_not_bol(); self.maybe_print_comment(item.span.lo()); self.print_outer_attributes(&item.attrs); match item.kind { ast::ForeignItemKind::Fn(ref decl, ref generics) => { self.head(""); - self.print_fn(decl, ast::FnHeader::default(), - Some(item.ident), - generics, &item.vis); + self.print_fn( + decl, + ast::FnHeader::default(), + Some(item.ident), + generics, + &item.vis, + ); self.end(); // end head-ibox self.s.word(";"); self.end(); // end the outer fn box @@ -1097,12 +1074,13 @@ impl<'a> State<'a> { } } - fn print_associated_const(&mut self, - ident: ast::Ident, - ty: &ast::Ty, - default: Option<&ast::Expr>, - vis: &ast::Visibility) - { + fn print_associated_const( + &mut self, + ident: ast::Ident, + ty: &ast::Ty, + default: Option<&ast::Expr>, + vis: &ast::Visibility, + ) { self.s.word(visibility_qualified(vis, "")); self.word_space("const"); self.print_ident(ident); @@ -1191,13 +1169,7 @@ impl<'a> State<'a> { } ast::ItemKind::Fn(ref sig, ref param_names, ref body) => { self.head(""); - self.print_fn( - &sig.decl, - sig.header, - Some(item.ident), - param_names, - &item.vis - ); + self.print_fn(&sig.decl, sig.header, Some(item.ident), param_names, &item.vis); self.s.word(" "); self.print_block_with_attrs(body, &item.attrs); } @@ -1215,7 +1187,6 @@ impl<'a> State<'a> { self.end(); // end inner head-block self.end(); // end outer head-block } - } ast::ItemKind::ForeignMod(ref nmod) => { self.head("extern"); @@ -1246,13 +1217,7 @@ impl<'a> State<'a> { self.end(); // end the outer ibox } ast::ItemKind::Enum(ref enum_definition, ref params) => { - self.print_enum_def( - enum_definition, - params, - item.ident, - item.span, - &item.vis - ); + self.print_enum_def(enum_definition, params, item.ident, item.span, &item.vis); } ast::ItemKind::Struct(ref struct_def, ref generics) => { self.head(visibility_qualified(&item.vis, "struct")); @@ -1262,13 +1227,15 @@ impl<'a> State<'a> { self.head(visibility_qualified(&item.vis, "union")); self.print_struct(struct_def, generics, item.ident, item.span, true); } - ast::ItemKind::Impl(unsafety, - polarity, - defaultness, - ref generics, - ref opt_trait, - ref ty, - ref impl_items) => { + ast::ItemKind::Impl( + unsafety, + polarity, + defaultness, + ref generics, + ref opt_trait, + ref ty, + ref impl_items, + ) => { self.head(""); self.print_visibility(&item.vis); self.print_defaultness(defaultness); @@ -1381,10 +1348,7 @@ impl<'a> State<'a> { self.print_path(&t.path, false, 0) } - fn print_formal_generic_params( - &mut self, - generic_params: &[ast::GenericParam] - ) { + fn print_formal_generic_params(&mut self, generic_params: &[ast::GenericParam]) { if !generic_params.is_empty() { self.s.word("for"); self.print_generic_params(generic_params); @@ -1397,10 +1361,14 @@ impl<'a> State<'a> { self.print_trait_ref(&t.trait_ref) } - crate fn print_enum_def(&mut self, enum_definition: &ast::EnumDef, - generics: &ast::Generics, ident: ast::Ident, - span: syntax_pos::Span, - visibility: &ast::Visibility) { + crate fn print_enum_def( + &mut self, + enum_definition: &ast::EnumDef, + generics: &ast::Generics, + ident: ast::Ident, + span: syntax_pos::Span, + visibility: &ast::Visibility, + ) { self.head(visibility_qualified(visibility, "enum")); self.print_ident(ident); self.print_generic_params(&generics.params); @@ -1409,9 +1377,7 @@ impl<'a> State<'a> { self.print_variants(&enum_definition.variants, span) } - crate fn print_variants(&mut self, - variants: &[ast::Variant], - span: syntax_pos::Span) { + crate fn print_variants(&mut self, variants: &[ast::Variant], span: syntax_pos::Span) { self.bopen(); for v in variants { self.space_if_not_bol(); @@ -1431,8 +1397,8 @@ impl<'a> State<'a> { ast::VisibilityKind::Public => self.word_nbsp("pub"), ast::VisibilityKind::Crate(sugar) => match sugar { ast::CrateSugar::PubCrate => self.word_nbsp("pub(crate)"), - ast::CrateSugar::JustCrate => self.word_nbsp("crate") - } + ast::CrateSugar::JustCrate => self.word_nbsp("crate"), + }, ast::VisibilityKind::Restricted { ref path, .. } => { let path = to_string(|s| s.print_path(path, false, 0)); if path == "self" || path == "super" { @@ -1451,27 +1417,26 @@ impl<'a> State<'a> { } } - crate fn print_struct(&mut self, - struct_def: &ast::VariantData, - generics: &ast::Generics, - ident: ast::Ident, - span: syntax_pos::Span, - print_finalizer: bool) { + crate fn print_struct( + &mut self, + struct_def: &ast::VariantData, + generics: &ast::Generics, + ident: ast::Ident, + span: syntax_pos::Span, + print_finalizer: bool, + ) { self.print_ident(ident); self.print_generic_params(&generics.params); match struct_def { ast::VariantData::Tuple(..) | ast::VariantData::Unit(..) => { if let ast::VariantData::Tuple(..) = struct_def { self.popen(); - self.commasep( - Inconsistent, struct_def.fields(), - |s, field| { - s.maybe_print_comment(field.span.lo()); - s.print_outer_attributes(&field.attrs); - s.print_visibility(&field.vis); - s.print_type(&field.ty) - } - ); + self.commasep(Inconsistent, struct_def.fields(), |s, field| { + s.maybe_print_comment(field.span.lo()); + s.print_outer_attributes(&field.attrs); + s.print_visibility(&field.vis); + s.print_type(&field.ty) + }); self.pclose(); } self.print_where_clause(&generics.where_clause); @@ -1586,8 +1551,9 @@ impl<'a> State<'a> { // Filter out empty `Tup` exprs created for the `redundant_semicolon` // lint, as they shouldn't be visible and interact poorly // with proc macros. - ast::ExprKind::Tup(ref exprs) if exprs.is_empty() - && expr.attrs.is_empty() => (), + ast::ExprKind::Tup(ref exprs) if exprs.is_empty() && expr.attrs.is_empty() => { + () + } _ => { self.space_if_not_bol(); self.print_expr_outer_attr_style(expr, false); @@ -1616,19 +1582,19 @@ impl<'a> State<'a> { self.print_block_maybe_unclosed(blk, &[], false) } - crate fn print_block_with_attrs(&mut self, - blk: &ast::Block, - attrs: &[ast::Attribute]) { + crate fn print_block_with_attrs(&mut self, blk: &ast::Block, attrs: &[ast::Attribute]) { self.print_block_maybe_unclosed(blk, attrs, true) } - crate fn print_block_maybe_unclosed(&mut self, - blk: &ast::Block, - attrs: &[ast::Attribute], - close_box: bool) { + crate fn print_block_maybe_unclosed( + &mut self, + blk: &ast::Block, + attrs: &[ast::Attribute], + close_box: bool, + ) { match blk.rules { BlockCheckMode::Unsafe(..) => self.word_space("unsafe"), - BlockCheckMode::Default => () + BlockCheckMode::Default => (), } self.maybe_print_comment(blk.span.lo()); self.ann.pre(self, AnnNode::Block(blk)); @@ -1663,7 +1629,7 @@ impl<'a> State<'a> { self.print_expr_cond_paren( scrutinee, Self::cond_needs_par(scrutinee) - || parser::needs_par_as_let_scrutinee(scrutinee.precedence().order()) + || parser::needs_par_as_let_scrutinee(scrutinee.precedence().order()), ) } @@ -1695,8 +1661,7 @@ impl<'a> State<'a> { } } - crate fn print_if(&mut self, test: &ast::Expr, blk: &ast::Block, - elseopt: Option<&ast::Expr>) { + crate fn print_if(&mut self, test: &ast::Expr, blk: &ast::Block, elseopt: Option<&ast::Expr>) { self.head("if"); self.print_expr_as_cond(test); @@ -1739,9 +1704,7 @@ impl<'a> State<'a> { match expr.kind { // These cases need parens due to the parse error observed in #26461: `if return {}` // parses as the erroneous construct `if (return {})`, not `if (return) {}`. - ast::ExprKind::Closure(..) | - ast::ExprKind::Ret(..) | - ast::ExprKind::Break(..) => true, + ast::ExprKind::Closure(..) | ast::ExprKind::Ret(..) | ast::ExprKind::Break(..) => true, _ => parser::contains_exterior_struct_lit(expr), } @@ -1758,8 +1721,7 @@ impl<'a> State<'a> { } } - fn print_expr_vec(&mut self, exprs: &[P<ast::Expr>], - attrs: &[Attribute]) { + fn print_expr_vec(&mut self, exprs: &[P<ast::Expr>], attrs: &[Attribute]) { self.ibox(INDENT_UNIT); self.s.word("["); self.print_inner_attributes_inline(attrs); @@ -1768,10 +1730,12 @@ impl<'a> State<'a> { self.end(); } - fn print_expr_repeat(&mut self, - element: &ast::Expr, - count: &ast::AnonConst, - attrs: &[Attribute]) { + fn print_expr_repeat( + &mut self, + element: &ast::Expr, + count: &ast::AnonConst, + attrs: &[Attribute], + ) { self.ibox(INDENT_UNIT); self.s.word("["); self.print_inner_attributes_inline(attrs); @@ -1782,11 +1746,13 @@ impl<'a> State<'a> { self.end(); } - fn print_expr_struct(&mut self, - path: &ast::Path, - fields: &[ast::Field], - wth: &Option<P<ast::Expr>>, - attrs: &[Attribute]) { + fn print_expr_struct( + &mut self, + path: &ast::Path, + fields: &[ast::Field], + wth: &Option<P<ast::Expr>>, + attrs: &[Attribute], + ) { self.print_path(path, true, 0); self.s.word("{"); self.print_inner_attributes_inline(attrs); @@ -1802,7 +1768,8 @@ impl<'a> State<'a> { s.print_expr(&field.expr); s.end(); }, - |f| f.span); + |f| f.span, + ); match *wth { Some(ref expr) => { self.ibox(INDENT_UNIT); @@ -1814,15 +1781,16 @@ impl<'a> State<'a> { self.print_expr(expr); self.end(); } - _ => if !fields.is_empty() { - self.s.word(",") + _ => { + if !fields.is_empty() { + self.s.word(",") + } } } self.s.word("}"); } - fn print_expr_tup(&mut self, exprs: &[P<ast::Expr>], - attrs: &[Attribute]) { + fn print_expr_tup(&mut self, exprs: &[P<ast::Expr>], attrs: &[Attribute]) { self.popen(); self.print_inner_attributes_inline(attrs); self.commasep_exprs(Inconsistent, &exprs[..]); @@ -1832,22 +1800,17 @@ impl<'a> State<'a> { self.pclose() } - fn print_expr_call(&mut self, - func: &ast::Expr, - args: &[P<ast::Expr>]) { - let prec = - match func.kind { - ast::ExprKind::Field(..) => parser::PREC_FORCE_PAREN, - _ => parser::PREC_POSTFIX, - }; + fn print_expr_call(&mut self, func: &ast::Expr, args: &[P<ast::Expr>]) { + let prec = match func.kind { + ast::ExprKind::Field(..) => parser::PREC_FORCE_PAREN, + _ => parser::PREC_POSTFIX, + }; self.print_expr_maybe_paren(func, prec); self.print_call_post(args) } - fn print_expr_method_call(&mut self, - segment: &ast::PathSegment, - args: &[P<ast::Expr>]) { + fn print_expr_method_call(&mut self, segment: &ast::PathSegment, args: &[P<ast::Expr>]) { let base_args = &args[1..]; self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX); self.s.word("."); @@ -1858,10 +1821,7 @@ impl<'a> State<'a> { self.print_call_post(base_args) } - fn print_expr_binary(&mut self, - op: ast::BinOp, - lhs: &ast::Expr, - rhs: &ast::Expr) { + fn print_expr_binary(&mut self, op: ast::BinOp, lhs: &ast::Expr, rhs: &ast::Expr) { let assoc_op = AssocOp::from_ast_binop(op.node); let prec = assoc_op.precedence() as i8; let fixity = assoc_op.fixity(); @@ -1876,8 +1836,8 @@ impl<'a> State<'a> { // These cases need parens: `x as i32 < y` has the parser thinking that `i32 < y` is // the beginning of a path type. It starts trying to parse `x as (i32 < y ...` instead // of `(x as i32) < ...`. We need to convince it _not_ to do that. - (&ast::ExprKind::Cast { .. }, ast::BinOpKind::Lt) | - (&ast::ExprKind::Cast { .. }, ast::BinOpKind::Shl) => parser::PREC_FORCE_PAREN, + (&ast::ExprKind::Cast { .. }, ast::BinOpKind::Lt) + | (&ast::ExprKind::Cast { .. }, ast::BinOpKind::Shl) => parser::PREC_FORCE_PAREN, // We are given `(let _ = a) OP b`. // // - When `OP <= LAnd` we should print `let _ = a OP b` to avoid redundant parens @@ -1898,17 +1858,17 @@ impl<'a> State<'a> { self.print_expr_maybe_paren(rhs, right_prec) } - fn print_expr_unary(&mut self, - op: ast::UnOp, - expr: &ast::Expr) { + fn print_expr_unary(&mut self, op: ast::UnOp, expr: &ast::Expr) { self.s.word(ast::UnOp::to_string(op)); self.print_expr_maybe_paren(expr, parser::PREC_PREFIX) } - fn print_expr_addr_of(&mut self, - kind: ast::BorrowKind, - mutability: ast::Mutability, - expr: &ast::Expr) { + fn print_expr_addr_of( + &mut self, + kind: ast::BorrowKind, + mutability: ast::Mutability, + expr: &ast::Expr, + ) { self.s.word("&"); match kind { ast::BorrowKind::Ref => self.print_mutability(mutability, false), @@ -1924,9 +1884,7 @@ impl<'a> State<'a> { self.print_expr_outer_attr_style(expr, true) } - fn print_expr_outer_attr_style(&mut self, - expr: &ast::Expr, - is_inline: bool) { + fn print_expr_outer_attr_style(&mut self, expr: &ast::Expr, is_inline: bool) { self.maybe_print_comment(expr.span.lo()); let attrs = &expr.attrs; @@ -2038,7 +1996,13 @@ impl<'a> State<'a> { self.bclose(expr.span); } ast::ExprKind::Closure( - capture_clause, asyncness, movability, ref decl, ref body, _) => { + capture_clause, + asyncness, + movability, + ref decl, + ref body, + _, + ) => { self.print_movability(movability); self.print_asyncness(asyncness); self.print_capture_clause(capture_clause); @@ -2121,12 +2085,8 @@ impl<'a> State<'a> { self.print_expr_maybe_paren(e, fake_prec); } } - ast::ExprKind::Path(None, ref path) => { - self.print_path(path, true, 0) - } - ast::ExprKind::Path(Some(ref qself), ref path) => { - self.print_qpath(path, qself, true) - } + ast::ExprKind::Path(None, ref path) => self.print_path(path, true, 0), + ast::ExprKind::Path(Some(ref qself), ref path) => self.print_qpath(path, qself, true), ast::ExprKind::Break(opt_label, ref opt_expr) => { self.s.word("break"); self.s.space(); @@ -2165,10 +2125,9 @@ impl<'a> State<'a> { let mut ch = constraint.chars(); match ch.next() { Some('=') if out.is_rw => { - s.print_string(&format!("+{}", ch.as_str()), - ast::StrStyle::Cooked) + s.print_string(&format!("+{}", ch.as_str()), ast::StrStyle::Cooked) } - _ => s.print_string(&constraint, ast::StrStyle::Cooked) + _ => s.print_string(&constraint, ast::StrStyle::Cooked), } s.popen(); s.print_expr(&out.expr); @@ -2186,8 +2145,7 @@ impl<'a> State<'a> { self.s.space(); self.word_space(":"); - self.commasep(Inconsistent, &a.clobbers, - |s, co| { + self.commasep(Inconsistent, &a.clobbers, |s, co| { s.print_string(&co.as_str(), ast::StrStyle::Cooked); }); @@ -2205,10 +2163,9 @@ impl<'a> State<'a> { if !options.is_empty() { self.s.space(); self.word_space(":"); - self.commasep(Inconsistent, &options, - |s, &co| { - s.print_string(co, ast::StrStyle::Cooked); - }); + self.commasep(Inconsistent, &options, |s, &co| { + s.print_string(co, ast::StrStyle::Cooked); + }); } self.pclose(); @@ -2219,7 +2176,7 @@ impl<'a> State<'a> { self.print_inner_attributes_inline(attrs); self.print_expr(e); self.pclose(); - }, + } ast::ExprKind::Yield(ref e) => { self.s.word("yield"); match *e { @@ -2227,7 +2184,7 @@ impl<'a> State<'a> { self.s.space(); self.print_expr_maybe_paren(expr, parser::PREC_JUMP); } - _ => () + _ => (), } } ast::ExprKind::Try(ref e) => { @@ -2266,11 +2223,7 @@ impl<'a> State<'a> { self.ann.post(self, AnnNode::Name(&name)) } - fn print_qpath(&mut self, - path: &ast::Path, - qself: &ast::QSelf, - colons_before_params: bool) - { + fn print_qpath(&mut self, path: &ast::Path, qself: &ast::QSelf, colons_before_params: bool) { self.s.word("<"); self.print_type(&qself.ty); if qself.position > 0 { @@ -2285,7 +2238,7 @@ impl<'a> State<'a> { self.print_ident(item_segment.ident); match item_segment.args { Some(ref args) => self.print_generic_args(args, colons_before_params), - None => {}, + None => {} } } @@ -2293,7 +2246,7 @@ impl<'a> State<'a> { self.maybe_print_comment(pat.span.lo()); self.ann.pre(self, AnnNode::Pat(pat)); /* Pat isn't normalized, but the beauty of it - is that it doesn't matter */ + is that it doesn't matter */ match pat.kind { PatKind::Wild => self.s.word("_"), PatKind::Ident(binding_mode, ident, ref sub) => { @@ -2334,7 +2287,8 @@ impl<'a> State<'a> { self.nbsp(); self.word_space("{"); self.commasep_cmnt( - Consistent, &fields[..], + Consistent, + &fields[..], |s, f| { s.cbox(INDENT_UNIT); if !f.is_shorthand { @@ -2344,9 +2298,12 @@ impl<'a> State<'a> { s.print_pat(&f.pat); s.end(); }, - |f| f.pat.span); + |f| f.pat.span, + ); if etc { - if !fields.is_empty() { self.word_space(","); } + if !fields.is_empty() { + self.word_space(","); + } self.s.word(".."); } self.s.space(); @@ -2461,12 +2418,14 @@ impl<'a> State<'a> { } } - crate fn print_fn(&mut self, - decl: &ast::FnDecl, - header: ast::FnHeader, - name: Option<ast::Ident>, - generics: &ast::Generics, - vis: &ast::Visibility) { + crate fn print_fn( + &mut self, + decl: &ast::FnDecl, + header: ast::FnHeader, + name: Option<ast::Ident>, + generics: &ast::Generics, + vis: &ast::Visibility, + ) { self.print_fn_header_info(header, vis); if let Some(name) = name { @@ -2489,7 +2448,7 @@ impl<'a> State<'a> { crate fn print_movability(&mut self, movability: ast::Movability) { match movability { ast::Movability::Static => self.word_space("static"), - ast::Movability::Movable => {}, + ast::Movability::Movable => {} } } @@ -2502,7 +2461,7 @@ impl<'a> State<'a> { crate fn print_capture_clause(&mut self, capture_clause: ast::CaptureBy) { match capture_clause { ast::CaptureBy::Value => self.word_space("move"), - ast::CaptureBy::Ref => {}, + ast::CaptureBy::Ref => {} } } @@ -2538,7 +2497,10 @@ impl<'a> State<'a> { } crate fn print_lifetime_bounds( - &mut self, lifetime: ast::Lifetime, bounds: &ast::GenericBounds) { + &mut self, + lifetime: ast::Lifetime, + bounds: &ast::GenericBounds, + ) { self.print_lifetime(lifetime); if !bounds.is_empty() { self.s.word(": "); @@ -2616,14 +2578,18 @@ impl<'a> State<'a> { self.print_type(bounded_ty); self.print_type_bounds(":", bounds); } - ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate{ref lifetime, - ref bounds, - ..}) => { + ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate { + ref lifetime, + ref bounds, + .. + }) => { self.print_lifetime_bounds(*lifetime, bounds); } - ast::WherePredicate::EqPredicate(ast::WhereEqPredicate{ref lhs_ty, - ref rhs_ty, - ..}) => { + ast::WherePredicate::EqPredicate(ast::WhereEqPredicate { + ref lhs_ty, + ref rhs_ty, + .. + }) => { self.print_type(lhs_ty); self.s.space(); self.word_space("="); @@ -2668,7 +2634,11 @@ impl<'a> State<'a> { pub fn print_mutability(&mut self, mutbl: ast::Mutability, print_const: bool) { match mutbl { ast::Mutability::Mut => self.word_nbsp("mut"), - ast::Mutability::Not => if print_const { self.word_nbsp("const"); }, + ast::Mutability::Not => { + if print_const { + self.word_nbsp("const"); + } + } } } @@ -2716,13 +2686,14 @@ impl<'a> State<'a> { } } - crate fn print_ty_fn(&mut self, - ext: ast::Extern, - unsafety: ast::Unsafety, - decl: &ast::FnDecl, - name: Option<ast::Ident>, - generic_params: &[ast::GenericParam]) - { + crate fn print_ty_fn( + &mut self, + ext: ast::Extern, + unsafety: ast::Unsafety, + decl: &ast::FnDecl, + name: Option<ast::Ident>, + generic_params: &[ast::GenericParam], + ) { self.ibox(INDENT_UNIT); if !generic_params.is_empty() { self.s.word("for"); @@ -2730,23 +2701,24 @@ impl<'a> State<'a> { } let generics = ast::Generics { params: Vec::new(), - where_clause: ast::WhereClause { - predicates: Vec::new(), - span: syntax_pos::DUMMY_SP, - }, + where_clause: ast::WhereClause { predicates: Vec::new(), span: syntax_pos::DUMMY_SP }, span: syntax_pos::DUMMY_SP, }; - self.print_fn(decl, - ast::FnHeader { unsafety, ext, ..ast::FnHeader::default() }, - name, - &generics, - &source_map::dummy_spanned(ast::VisibilityKind::Inherited)); + self.print_fn( + decl, + ast::FnHeader { unsafety, ext, ..ast::FnHeader::default() }, + name, + &generics, + &source_map::dummy_spanned(ast::VisibilityKind::Inherited), + ); self.end(); } - crate fn maybe_print_trailing_comment(&mut self, span: syntax_pos::Span, - next_pos: Option<BytePos>) - { + crate fn maybe_print_trailing_comment( + &mut self, + span: syntax_pos::Span, + next_pos: Option<BytePos>, + ) { if let Some(cmnts) = self.comments() { if let Some(cmnt) = cmnts.trailing_comment(span, next_pos) { self.print_comment(&cmnt); @@ -2765,14 +2737,12 @@ impl<'a> State<'a> { } } - crate fn print_fn_header_info(&mut self, - header: ast::FnHeader, - vis: &ast::Visibility) { + crate fn print_fn_header_info(&mut self, header: ast::FnHeader, vis: &ast::Visibility) { self.s.word(visibility_qualified(vis, "")); match header.constness.node { ast::Constness::NotConst => {} - ast::Constness::Const => self.word_nbsp("const") + ast::Constness::Const => self.word_nbsp("const"), } self.print_asyncness(header.asyncness.node); @@ -2795,7 +2765,7 @@ impl<'a> State<'a> { crate fn print_unsafety(&mut self, s: ast::Unsafety) { match s { - ast::Unsafety::Normal => {}, + ast::Unsafety::Normal => {} ast::Unsafety::Unsafe => self.word_nbsp("unsafe"), } } diff --git a/src/libsyntax/print/pprust/tests.rs b/src/libsyntax/print/pprust/tests.rs index d7725acb5d4..2a1a1ad58f1 100644 --- a/src/libsyntax/print/pprust/tests.rs +++ b/src/libsyntax/print/pprust/tests.rs @@ -6,12 +6,20 @@ use crate::with_default_globals; use syntax_pos; fn fun_to_string( - decl: &ast::FnDecl, header: ast::FnHeader, name: ast::Ident, generics: &ast::Generics + decl: &ast::FnDecl, + header: ast::FnHeader, + name: ast::Ident, + generics: &ast::Generics, ) -> String { to_string(|s| { s.head(""); - s.print_fn(decl, header, Some(name), - generics, &source_map::dummy_spanned(ast::VisibilityKind::Inherited)); + s.print_fn( + decl, + header, + Some(name), + generics, + &source_map::dummy_spanned(ast::VisibilityKind::Inherited), + ); s.end(); // Close the head box. s.end(); // Close the outer box. }) @@ -32,12 +40,7 @@ fn test_fun_to_string() { }; let generics = ast::Generics::default(); assert_eq!( - fun_to_string( - &decl, - ast::FnHeader::default(), - abba_ident, - &generics - ), + fun_to_string(&decl, ast::FnHeader::default(), abba_ident, &generics), "fn abba()" ); }) diff --git a/src/libsyntax/ptr.rs b/src/libsyntax/ptr.rs index e75cc8b1756..4597624ef88 100644 --- a/src/libsyntax/ptr.rs +++ b/src/libsyntax/ptr.rs @@ -21,31 +21,30 @@ //! implementation changes (using a special thread-local heap, for example). //! Moreover, a switch to, e.g., `P<'a, T>` would be easy and mostly automated. -use std::fmt::{self, Display, Debug}; +use std::fmt::{self, Debug, Display}; use std::iter::FromIterator; use std::ops::{Deref, DerefMut}; use std::{slice, vec}; -use rustc_serialize::{Encodable, Decodable, Encoder, Decoder}; +use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; -use rustc_data_structures::stable_hasher::{StableHasher, HashStable}; +use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; /// An owned smart pointer. pub struct P<T: ?Sized> { - ptr: Box<T> + ptr: Box<T>, } /// Construct a `P<T>` from a `T` value. #[allow(non_snake_case)] pub fn P<T: 'static>(value: T) -> P<T> { - P { - ptr: box value - } + P { ptr: box value } } impl<T: 'static> P<T> { /// Move out of the pointer. /// Intended for chaining transformations not covered by `map`. - pub fn and_then<U, F>(self, f: F) -> U where + pub fn and_then<U, F>(self, f: F) -> U + where F: FnOnce(T) -> U, { f(*self.ptr) @@ -57,7 +56,8 @@ impl<T: 'static> P<T> { } /// Produce a new `P<T>` from `self` without reallocating. - pub fn map<F>(mut self, f: F) -> P<T> where + pub fn map<F>(mut self, f: F) -> P<T> + where F: FnOnce(T) -> T, { let x = f(*self.ptr); @@ -67,7 +67,8 @@ impl<T: 'static> P<T> { } /// Optionally produce a new `P<T>` from `self` without reallocating. - pub fn filter_map<F>(mut self, f: F) -> Option<P<T>> where + pub fn filter_map<F>(mut self, f: F) -> Option<P<T>> + where F: FnOnce(T) -> Option<T>, { *self.ptr = f(*self.ptr)?; @@ -174,7 +175,7 @@ impl<T> Into<Vec<T>> for P<[T]> { } impl<T> FromIterator<T> for P<[T]> { - fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> P<[T]> { + fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> P<[T]> { P::from_vec(iter.into_iter().collect()) } } @@ -209,7 +210,8 @@ impl<T: Decodable> Decodable for P<[T]> { } impl<CTX, T> HashStable<CTX> for P<T> - where T: ?Sized + HashStable<CTX> +where + T: ?Sized + HashStable<CTX>, { fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) { (**self).hash_stable(hcx, hasher); diff --git a/src/libsyntax/show_span.rs b/src/libsyntax/show_span.rs index 5e0cf9eea78..fb641239dfa 100644 --- a/src/libsyntax/show_span.rs +++ b/src/libsyntax/show_span.rs @@ -22,7 +22,7 @@ impl FromStr for Mode { "expr" => Mode::Expression, "pat" => Mode::Pattern, "ty" => Mode::Type, - _ => return Err(()) + _ => return Err(()), }; Ok(mode) } @@ -60,16 +60,11 @@ impl<'a> Visitor<'a> for ShowSpanVisitor<'a> { } } -pub fn run(span_diagnostic: &errors::Handler, - mode: &str, - krate: &ast::Crate) { +pub fn run(span_diagnostic: &errors::Handler, mode: &str, krate: &ast::Crate) { let mode = match mode.parse().ok() { Some(mode) => mode, - None => return - }; - let mut v = ShowSpanVisitor { - span_diagnostic, - mode, + None => return, }; + let mut v = ShowSpanVisitor { span_diagnostic, mode }; visit::walk_crate(&mut v, krate); } diff --git a/src/libsyntax/token.rs b/src/libsyntax/token.rs index 263f8192241..2242fdc9ed7 100644 --- a/src/libsyntax/token.rs +++ b/src/libsyntax/token.rs @@ -1,7 +1,7 @@ pub use BinOpToken::*; -pub use Nonterminal::*; pub use DelimToken::*; pub use LitKind::*; +pub use Nonterminal::*; pub use TokenKind::*; use crate::ast; @@ -12,11 +12,11 @@ use crate::tokenstream::TokenTree; use syntax_pos::symbol::Symbol; use syntax_pos::{self, Span, DUMMY_SP}; -use std::fmt; -use std::mem; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::sync::Lrc; use rustc_macros::HashStable_Generic; +use std::fmt; +use std::mem; #[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] #[derive(HashStable_Generic)] @@ -83,20 +83,23 @@ impl fmt::Display for Lit { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let Lit { kind, symbol, suffix } = *self; match kind { - Byte => write!(f, "b'{}'", symbol)?, - Char => write!(f, "'{}'", symbol)?, - Str => write!(f, "\"{}\"", symbol)?, - StrRaw(n) => write!(f, "r{delim}\"{string}\"{delim}", - delim="#".repeat(n as usize), - string=symbol)?, - ByteStr => write!(f, "b\"{}\"", symbol)?, - ByteStrRaw(n) => write!(f, "br{delim}\"{string}\"{delim}", - delim="#".repeat(n as usize), - string=symbol)?, - Integer | - Float | - Bool | - Err => write!(f, "{}", symbol)?, + Byte => write!(f, "b'{}'", symbol)?, + Char => write!(f, "'{}'", symbol)?, + Str => write!(f, "\"{}\"", symbol)?, + StrRaw(n) => write!( + f, + "r{delim}\"{string}\"{delim}", + delim = "#".repeat(n as usize), + string = symbol + )?, + ByteStr => write!(f, "b\"{}\"", symbol)?, + ByteStrRaw(n) => write!( + f, + "br{delim}\"{string}\"{delim}", + delim = "#".repeat(n as usize), + string = symbol + )?, + Integer | Float | Bool | Err => write!(f, "{}", symbol)?, } if let Some(suffix) = suffix { @@ -149,48 +152,41 @@ pub fn ident_can_begin_expr(name: ast::Name, span: Span, is_raw: bool) -> bool { } pub fn token_can_begin_expr(ident_token: &Token) -> bool { - !ident_token.is_reserved_ident() || - ident_token.is_path_segment_keyword() || - match ident_token.kind { - TokenKind::Ident(ident, _) => [ - kw::Async, - kw::Do, - kw::Box, - kw::Break, - kw::Continue, - kw::False, - kw::For, - kw::If, - kw::Let, - kw::Loop, - kw::Match, - kw::Move, - kw::Return, - kw::True, - kw::Unsafe, - kw::While, - kw::Yield, - kw::Static, - ].contains(&ident), - _=> false, - } + !ident_token.is_reserved_ident() + || ident_token.is_path_segment_keyword() + || match ident_token.kind { + TokenKind::Ident(ident, _) => [ + kw::Async, + kw::Do, + kw::Box, + kw::Break, + kw::Continue, + kw::False, + kw::For, + kw::If, + kw::Let, + kw::Loop, + kw::Match, + kw::Move, + kw::Return, + kw::True, + kw::Unsafe, + kw::While, + kw::Yield, + kw::Static, + ] + .contains(&ident), + _ => false, + } } fn ident_can_begin_type(name: ast::Name, span: Span, is_raw: bool) -> bool { let ident_token = Token::new(Ident(name, is_raw), span); - !ident_token.is_reserved_ident() || - ident_token.is_path_segment_keyword() || - [ - kw::Underscore, - kw::For, - kw::Impl, - kw::Fn, - kw::Unsafe, - kw::Extern, - kw::Typeof, - kw::Dyn, - ].contains(&name) + !ident_token.is_reserved_ident() + || ident_token.is_path_segment_keyword() + || [kw::Underscore, kw::For, kw::Impl, kw::Fn, kw::Unsafe, kw::Extern, kw::Typeof, kw::Dyn] + .contains(&name) } #[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] @@ -249,7 +245,6 @@ pub enum TokenKind { // Junk. These carry no data because we don't really care about the data // they *would* carry, and don't really want to allocate a new ident for // them. Instead, users could extract that from the associated span. - /// Whitespace. Whitespace, /// A comment. @@ -282,7 +277,7 @@ impl TokenKind { match *self { Comma => Some(vec![Dot, Lt, Semi]), Semi => Some(vec![Colon, Comma]), - _ => None + _ => None, } } } @@ -309,9 +304,8 @@ impl Token { pub fn is_op(&self) -> bool { match self.kind { - OpenDelim(..) | CloseDelim(..) | Literal(..) | DocComment(..) | - Ident(..) | Lifetime(..) | Interpolated(..) | - Whitespace | Comment | Shebang(..) | Eof => false, + OpenDelim(..) | CloseDelim(..) | Literal(..) | DocComment(..) | Ident(..) + | Lifetime(..) | Interpolated(..) | Whitespace | Comment | Shebang(..) | Eof => false, _ => true, } } @@ -385,22 +379,25 @@ impl Token { Interpolated(ref nt) => match **nt { NtExpr(..) | NtBlock(..) | NtLiteral(..) => true, _ => false, - } + }, _ => self.can_begin_literal_or_bool(), } } /// Returns `true` if the token can appear at the start of a generic bound. pub fn can_begin_bound(&self) -> bool { - self.is_path_start() || self.is_lifetime() || self.is_keyword(kw::For) || - self == &Question || self == &OpenDelim(Paren) + self.is_path_start() + || self.is_lifetime() + || self.is_keyword(kw::For) + || self == &Question + || self == &OpenDelim(Paren) } /// Returns `true` if the token is any literal pub fn is_lit(&self) -> bool { match self.kind { Literal(..) => true, - _ => false, + _ => false, } } @@ -412,9 +409,9 @@ impl Token { Ident(name, false) if name.is_bool_lit() => true, Interpolated(ref nt) => match **nt { NtLiteral(..) => true, - _ => false, + _ => false, }, - _ => false, + _ => false, } } @@ -483,8 +480,7 @@ impl Token { /// Returns `true` if the token is either the `mut` or `const` keyword. pub fn is_mutability(&self) -> bool { - self.is_keyword(kw::Mut) || - self.is_keyword(kw::Const) + self.is_keyword(kw::Mut) || self.is_keyword(kw::Const) } pub fn is_qpath_start(&self) -> bool { @@ -492,8 +488,11 @@ impl Token { } pub fn is_path_start(&self) -> bool { - self == &ModSep || self.is_qpath_start() || self.is_path() || - self.is_path_segment_keyword() || self.is_ident() && !self.is_reserved_ident() + self == &ModSep + || self.is_qpath_start() + || self.is_path() + || self.is_path_segment_keyword() + || self.is_ident() && !self.is_reserved_ident() } /// Returns `true` if the token is a given keyword, `kw`. @@ -589,11 +588,11 @@ impl Token { _ => return None, }, - Le | EqEq | Ne | Ge | AndAnd | OrOr | Tilde | BinOpEq(..) | At | DotDotDot | - DotDotEq | Comma | Semi | ModSep | RArrow | LArrow | FatArrow | Pound | Dollar | - Question | OpenDelim(..) | CloseDelim(..) | - Literal(..) | Ident(..) | Lifetime(..) | Interpolated(..) | DocComment(..) | - Whitespace | Comment | Shebang(..) | Unknown(..) | Eof => return None, + Le | EqEq | Ne | Ge | AndAnd | OrOr | Tilde | BinOpEq(..) | At | DotDotDot + | DotDotEq | Comma | Semi | ModSep | RArrow | LArrow | FatArrow | Pound | Dollar + | Question | OpenDelim(..) | CloseDelim(..) | Literal(..) | Ident(..) + | Lifetime(..) | Interpolated(..) | DocComment(..) | Whitespace | Comment + | Shebang(..) | Unknown(..) | Eof => return None, }; Some(Token::new(kind, self.span.to(joint.span))) @@ -603,54 +602,51 @@ impl Token { // *probably* equal here rather than actual equality crate fn probably_equal_for_proc_macro(&self, other: &Token) -> bool { if mem::discriminant(&self.kind) != mem::discriminant(&other.kind) { - return false + return false; } match (&self.kind, &other.kind) { - (&Eq, &Eq) | - (&Lt, &Lt) | - (&Le, &Le) | - (&EqEq, &EqEq) | - (&Ne, &Ne) | - (&Ge, &Ge) | - (&Gt, &Gt) | - (&AndAnd, &AndAnd) | - (&OrOr, &OrOr) | - (&Not, &Not) | - (&Tilde, &Tilde) | - (&At, &At) | - (&Dot, &Dot) | - (&DotDot, &DotDot) | - (&DotDotDot, &DotDotDot) | - (&DotDotEq, &DotDotEq) | - (&Comma, &Comma) | - (&Semi, &Semi) | - (&Colon, &Colon) | - (&ModSep, &ModSep) | - (&RArrow, &RArrow) | - (&LArrow, &LArrow) | - (&FatArrow, &FatArrow) | - (&Pound, &Pound) | - (&Dollar, &Dollar) | - (&Question, &Question) | - (&Whitespace, &Whitespace) | - (&Comment, &Comment) | - (&Eof, &Eof) => true, - - (&BinOp(a), &BinOp(b)) | - (&BinOpEq(a), &BinOpEq(b)) => a == b, - - (&OpenDelim(a), &OpenDelim(b)) | - (&CloseDelim(a), &CloseDelim(b)) => a == b, - - (&DocComment(a), &DocComment(b)) | - (&Shebang(a), &Shebang(b)) => a == b, + (&Eq, &Eq) + | (&Lt, &Lt) + | (&Le, &Le) + | (&EqEq, &EqEq) + | (&Ne, &Ne) + | (&Ge, &Ge) + | (&Gt, &Gt) + | (&AndAnd, &AndAnd) + | (&OrOr, &OrOr) + | (&Not, &Not) + | (&Tilde, &Tilde) + | (&At, &At) + | (&Dot, &Dot) + | (&DotDot, &DotDot) + | (&DotDotDot, &DotDotDot) + | (&DotDotEq, &DotDotEq) + | (&Comma, &Comma) + | (&Semi, &Semi) + | (&Colon, &Colon) + | (&ModSep, &ModSep) + | (&RArrow, &RArrow) + | (&LArrow, &LArrow) + | (&FatArrow, &FatArrow) + | (&Pound, &Pound) + | (&Dollar, &Dollar) + | (&Question, &Question) + | (&Whitespace, &Whitespace) + | (&Comment, &Comment) + | (&Eof, &Eof) => true, + + (&BinOp(a), &BinOp(b)) | (&BinOpEq(a), &BinOpEq(b)) => a == b, + + (&OpenDelim(a), &OpenDelim(b)) | (&CloseDelim(a), &CloseDelim(b)) => a == b, + + (&DocComment(a), &DocComment(b)) | (&Shebang(a), &Shebang(b)) => a == b, (&Literal(a), &Literal(b)) => a == b, (&Lifetime(a), &Lifetime(b)) => a == b, - (&Ident(a, b), &Ident(c, d)) => b == d && (a == c || - a == kw::DollarCrate || - c == kw::DollarCrate), + (&Ident(a, b), &Ident(c, d)) => { + b == d && (a == c || a == kw::DollarCrate || c == kw::DollarCrate) + } (&Interpolated(_), &Interpolated(_)) => false, @@ -693,8 +689,9 @@ pub enum Nonterminal { impl PartialEq for Nonterminal { fn eq(&self, rhs: &Self) -> bool { match (self, rhs) { - (NtIdent(ident_lhs, is_raw_lhs), NtIdent(ident_rhs, is_raw_rhs)) => - ident_lhs == ident_rhs && is_raw_lhs == is_raw_rhs, + (NtIdent(ident_lhs, is_raw_lhs), NtIdent(ident_rhs, is_raw_rhs)) => { + ident_lhs == ident_rhs && is_raw_lhs == is_raw_rhs + } (NtLifetime(ident_lhs), NtLifetime(ident_rhs)) => ident_lhs == ident_rhs, (NtTT(tt_lhs), NtTT(tt_rhs)) => tt_lhs == tt_rhs, // FIXME: Assume that all "complex" nonterminal are not equal, we can't compare them @@ -730,7 +727,8 @@ impl fmt::Debug for Nonterminal { } impl<CTX> HashStable<CTX> for Nonterminal - where CTX: crate::HashStableContext +where + CTX: crate::HashStableContext, { fn hash_stable(&self, _hcx: &mut CTX, _hasher: &mut StableHasher) { panic!("interpolated tokens should not be present in the HIR") diff --git a/src/libsyntax/tokenstream.rs b/src/libsyntax/tokenstream.rs index 491b9a9ade4..d9ea4a0137f 100644 --- a/src/libsyntax/tokenstream.rs +++ b/src/libsyntax/tokenstream.rs @@ -15,11 +15,11 @@ use crate::token::{self, DelimToken, Token, TokenKind}; -use syntax_pos::{Span, DUMMY_SP}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; -use rustc_macros::HashStable_Generic; use rustc_data_structures::sync::Lrc; -use smallvec::{SmallVec, smallvec}; +use rustc_macros::HashStable_Generic; +use smallvec::{smallvec, SmallVec}; +use syntax_pos::{Span, DUMMY_SP}; use std::{iter, mem}; @@ -51,7 +51,8 @@ where DelimSpan: Send + Sync, DelimToken: Send + Sync, TokenStream: Send + Sync, -{} +{ +} impl TokenTree { /// Checks if this TokenTree is equal to the other, regardless of span information. @@ -118,7 +119,8 @@ impl TokenTree { } impl<CTX> HashStable<CTX> for TokenStream - where CTX: crate::HashStableContext +where + CTX: crate::HashStableContext, { fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) { for sub_tt in self.trees() { @@ -144,7 +146,7 @@ rustc_data_structures::static_assert_size!(TokenStream, 8); #[derive(Clone, Copy, Debug, PartialEq, RustcEncodable, RustcDecodable)] pub enum IsJoint { Joint, - NonJoint + NonJoint, } use IsJoint::*; @@ -160,12 +162,16 @@ impl TokenStream { if let Some((_, next)) = iter.peek() { let sp = match (&ts, &next) { (_, (TokenTree::Token(Token { kind: token::Comma, .. }), _)) => continue, - ((TokenTree::Token(token_left), NonJoint), - (TokenTree::Token(token_right), _)) - if ((token_left.is_ident() && !token_left.is_reserved_ident()) - || token_left.is_lit()) && - ((token_right.is_ident() && !token_right.is_reserved_ident()) - || token_right.is_lit()) => token_left.span, + ( + (TokenTree::Token(token_left), NonJoint), + (TokenTree::Token(token_right), _), + ) if ((token_left.is_ident() && !token_left.is_reserved_ident()) + || token_left.is_lit()) + && ((token_right.is_ident() && !token_right.is_reserved_ident()) + || token_right.is_lit()) => + { + token_left.span + } ((TokenTree::Delimited(sp, ..), NonJoint), _) => sp.entire(), _ => continue, }; @@ -251,10 +257,7 @@ impl TokenStream { // Determine how much the first stream will be extended. // Needed to avoid quadratic blow up from on-the-fly // reallocations (#57735). - let num_appends = streams.iter() - .skip(1) - .map(|ts| ts.len()) - .sum(); + let num_appends = streams.iter().skip(1).map(|ts| ts.len()).sum(); // Get the first stream. If it's `None`, create an empty // stream. @@ -344,16 +347,13 @@ impl TokenStream { .iter() .enumerate() .map(|(i, (tree, is_joint))| (f(i, tree.clone()), *is_joint)) - .collect() + .collect(), )) } pub fn map<F: FnMut(TokenTree) -> TokenTree>(self, mut f: F) -> TokenStream { TokenStream(Lrc::new( - self.0 - .iter() - .map(|(tree, is_joint)| (f(tree.clone()), *is_joint)) - .collect() + self.0.iter().map(|(tree, is_joint)| (f(tree.clone()), *is_joint)).collect(), )) } } @@ -374,15 +374,12 @@ impl TokenStreamBuilder { // token tree marked with `Joint`... if let Some(TokenStream(ref mut last_stream_lrc)) = self.0.last_mut() { if let Some((TokenTree::Token(last_token), Joint)) = last_stream_lrc.last() { - // ...and `stream` is not empty and the first tree within it is // a token tree... let TokenStream(ref mut stream_lrc) = stream; if let Some((TokenTree::Token(token), is_joint)) = stream_lrc.first() { - // ...and the two tokens can be glued together... if let Some(glued_tok) = last_token.glue(&token) { - // ...then do so, by overwriting the last token // tree in `self` and removing the first token tree // from `stream`. This requires using `make_mut()` @@ -460,7 +457,7 @@ impl Cursor { } pub fn look_ahead(&self, n: usize) -> Option<TokenTree> { - self.stream.0[self.index ..].get(n).map(|(tree, _)| tree.clone()) + self.stream.0[self.index..].get(n).map(|(tree, _)| tree.clone()) } } @@ -472,10 +469,7 @@ pub struct DelimSpan { impl DelimSpan { pub fn from_single(sp: Span) -> Self { - DelimSpan { - open: sp, - close: sp, - } + DelimSpan { open: sp, close: sp } } pub fn from_pair(open: Span, close: Span) -> Self { diff --git a/src/libsyntax/util/classify.rs b/src/libsyntax/util/classify.rs index 44560688750..60422a2e573 100644 --- a/src/libsyntax/util/classify.rs +++ b/src/libsyntax/util/classify.rs @@ -13,13 +13,13 @@ use crate::ast; /// isn't parsed as (if true {...} else {...} | x) | 5 pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool { match e.kind { - ast::ExprKind::If(..) | - ast::ExprKind::Match(..) | - ast::ExprKind::Block(..) | - ast::ExprKind::While(..) | - ast::ExprKind::Loop(..) | - ast::ExprKind::ForLoop(..) | - ast::ExprKind::TryBlock(..) => false, + ast::ExprKind::If(..) + | ast::ExprKind::Match(..) + | ast::ExprKind::Block(..) + | ast::ExprKind::While(..) + | ast::ExprKind::Loop(..) + | ast::ExprKind::ForLoop(..) + | ast::ExprKind::TryBlock(..) => false, _ => true, } } diff --git a/src/libsyntax/util/comments.rs b/src/libsyntax/util/comments.rs index 5e9b7bf8322..1d2b753b69a 100644 --- a/src/libsyntax/util/comments.rs +++ b/src/libsyntax/util/comments.rs @@ -1,10 +1,10 @@ pub use CommentStyle::*; use crate::ast; -use crate::source_map::SourceMap; use crate::sess::ParseSess; +use crate::source_map::SourceMap; -use syntax_pos::{BytePos, CharPos, Pos, FileName}; +use syntax_pos::{BytePos, CharPos, FileName, Pos}; use std::usize; @@ -33,24 +33,27 @@ pub struct Comment { } pub fn is_line_doc_comment(s: &str) -> bool { - let res = (s.starts_with("///") && *s.as_bytes().get(3).unwrap_or(&b' ') != b'/') || - s.starts_with("//!"); + let res = (s.starts_with("///") && *s.as_bytes().get(3).unwrap_or(&b' ') != b'/') + || s.starts_with("//!"); debug!("is {:?} a doc comment? {}", s, res); res } pub fn is_block_doc_comment(s: &str) -> bool { // Prevent `/**/` from being parsed as a doc comment - let res = ((s.starts_with("/**") && *s.as_bytes().get(3).unwrap_or(&b' ') != b'*') || - s.starts_with("/*!")) && s.len() >= 5; + let res = ((s.starts_with("/**") && *s.as_bytes().get(3).unwrap_or(&b' ') != b'*') + || s.starts_with("/*!")) + && s.len() >= 5; debug!("is {:?} a doc comment? {}", s, res); res } // FIXME(#64197): Try to privatize this again. pub fn is_doc_comment(s: &str) -> bool { - (s.starts_with("///") && is_line_doc_comment(s)) || s.starts_with("//!") || - (s.starts_with("/**") && is_block_doc_comment(s)) || s.starts_with("/*!") + (s.starts_with("///") && is_line_doc_comment(s)) + || s.starts_with("//!") + || (s.starts_with("/**") && is_block_doc_comment(s)) + || s.starts_with("/*!") } pub fn doc_comment_style(comment: &str) -> ast::AttrStyle { @@ -76,11 +79,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String { i += 1; } // like the first, a last line of all stars should be omitted - if j > i && - lines[j - 1] - .chars() - .skip(1) - .all(|c| c == '*') { + if j > i && lines[j - 1].chars().skip(1).all(|c| c == '*') { j -= 1; } @@ -122,9 +121,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String { } if can_trim { - lines.iter() - .map(|line| (&line[i + 1..line.len()]).to_string()) - .collect() + lines.iter().map(|line| (&line[i + 1..line.len()]).to_string()).collect() } else { lines } @@ -140,10 +137,8 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String { } if comment.starts_with("/*") { - let lines = comment[3..comment.len() - 2] - .lines() - .map(|s| s.to_string()) - .collect::<Vec<String>>(); + let lines = + comment[3..comment.len() - 2].lines().map(|s| s.to_string()).collect::<Vec<String>>(); let lines = vertical_trim(lines); let lines = horizontal_trim(lines); @@ -171,15 +166,18 @@ fn all_whitespace(s: &str, col: CharPos) -> Option<usize> { fn trim_whitespace_prefix(s: &str, col: CharPos) -> &str { let len = s.len(); match all_whitespace(&s, col) { - Some(col) => if col < len { &s[col..] } else { "" }, + Some(col) => { + if col < len { + &s[col..] + } else { + "" + } + } None => s, } } -fn split_block_comment_into_lines( - text: &str, - col: CharPos, -) -> Vec<String> { +fn split_block_comment_into_lines(text: &str, col: CharPos) -> Vec<String> { let mut res: Vec<String> = vec![]; let mut lines = text.lines(); // just push the first line diff --git a/src/libsyntax/util/lev_distance.rs b/src/libsyntax/util/lev_distance.rs index efb3c2396c3..f55b58d7d13 100644 --- a/src/libsyntax/util/lev_distance.rs +++ b/src/libsyntax/util/lev_distance.rs @@ -1,5 +1,5 @@ -use std::cmp; use crate::symbol::Symbol; +use std::cmp; #[cfg(test)] mod tests; @@ -43,36 +43,36 @@ pub fn lev_distance(a: &str, b: &str) -> usize { /// /// Besides Levenshtein, we use case insensitive comparison to improve accuracy on an edge case with /// a lower(upper)case letters mismatch. -pub fn find_best_match_for_name<'a, T>(iter_names: T, - lookup: &str, - dist: Option<usize>) -> Option<Symbol> - where T: Iterator<Item = &'a Symbol> { +pub fn find_best_match_for_name<'a, T>( + iter_names: T, + lookup: &str, + dist: Option<usize>, +) -> Option<Symbol> +where + T: Iterator<Item = &'a Symbol>, +{ let max_dist = dist.map_or_else(|| cmp::max(lookup.len(), 3) / 3, |d| d); let (case_insensitive_match, levenstein_match) = iter_names - .filter_map(|&name| { - let dist = lev_distance(lookup, &name.as_str()); - if dist <= max_dist { - Some((name, dist)) - } else { - None - } - }) - // Here we are collecting the next structure: - // (case_insensitive_match, (levenstein_match, levenstein_distance)) - .fold((None, None), |result, (candidate, dist)| { - ( - if candidate.as_str().to_uppercase() == lookup.to_uppercase() { - Some(candidate) - } else { - result.0 - }, - match result.1 { - None => Some((candidate, dist)), - Some((c, d)) => Some(if dist < d { (candidate, dist) } else { (c, d) }) - } - ) - }); + .filter_map(|&name| { + let dist = lev_distance(lookup, &name.as_str()); + if dist <= max_dist { Some((name, dist)) } else { None } + }) + // Here we are collecting the next structure: + // (case_insensitive_match, (levenstein_match, levenstein_distance)) + .fold((None, None), |result, (candidate, dist)| { + ( + if candidate.as_str().to_uppercase() == lookup.to_uppercase() { + Some(candidate) + } else { + result.0 + }, + match result.1 { + None => Some((candidate, dist)), + Some((c, d)) => Some(if dist < d { (candidate, dist) } else { (c, d) }), + }, + ) + }); if let Some(candidate) = case_insensitive_match { Some(candidate) // exact case insensitive match has a higher priority diff --git a/src/libsyntax/util/lev_distance/tests.rs b/src/libsyntax/util/lev_distance/tests.rs index 1a746a67ec0..f65f9275d03 100644 --- a/src/libsyntax/util/lev_distance/tests.rs +++ b/src/libsyntax/util/lev_distance/tests.rs @@ -4,9 +4,7 @@ use super::*; fn test_lev_distance() { use std::char::{from_u32, MAX}; // Test bytelength agnosticity - for c in (0..MAX as u32) - .filter_map(|i| from_u32(i)) - .map(|i| i.to_string()) { + for c in (0..MAX as u32).filter_map(|i| from_u32(i)).map(|i| i.to_string()) { assert_eq!(lev_distance(&c[..], &c[..]), 0); } @@ -31,10 +29,7 @@ fn test_find_best_match_for_name() { Some(Symbol::intern("aaab")) ); - assert_eq!( - find_best_match_for_name(input.iter(), "1111111111", None), - None - ); + assert_eq!(find_best_match_for_name(input.iter(), "1111111111", None), None); let input = vec![Symbol::intern("aAAA")]; assert_eq!( @@ -44,10 +39,7 @@ fn test_find_best_match_for_name() { let input = vec![Symbol::intern("AAAA")]; // Returns None because `lev_distance > max_dist / 3` - assert_eq!( - find_best_match_for_name(input.iter(), "aaaa", None), - None - ); + assert_eq!(find_best_match_for_name(input.iter(), "aaaa", None), None); let input = vec![Symbol::intern("AAAA")]; assert_eq!( diff --git a/src/libsyntax/util/literal.rs b/src/libsyntax/util/literal.rs index af7afab6b9b..27ce180a4bc 100644 --- a/src/libsyntax/util/literal.rs +++ b/src/libsyntax/util/literal.rs @@ -7,10 +7,10 @@ use crate::tokenstream::TokenTree; use log::debug; use rustc_data_structures::sync::Lrc; +use rustc_lexer::unescape::{unescape_byte, unescape_char}; +use rustc_lexer::unescape::{unescape_byte_str, unescape_str}; +use rustc_lexer::unescape::{unescape_raw_byte_str, unescape_raw_str}; use syntax_pos::Span; -use rustc_lexer::unescape::{unescape_char, unescape_byte}; -use rustc_lexer::unescape::{unescape_str, unescape_byte_str}; -use rustc_lexer::unescape::{unescape_raw_str, unescape_raw_byte_str}; use std::ascii; @@ -37,10 +37,16 @@ impl LitKind { assert!(symbol.is_bool_lit()); LitKind::Bool(symbol == kw::True) } - token::Byte => return unescape_byte(&symbol.as_str()) - .map(LitKind::Byte).map_err(|_| LitError::LexerError), - token::Char => return unescape_char(&symbol.as_str()) - .map(LitKind::Char).map_err(|_| LitError::LexerError), + token::Byte => { + return unescape_byte(&symbol.as_str()) + .map(LitKind::Byte) + .map_err(|_| LitError::LexerError); + } + token::Char => { + return unescape_char(&symbol.as_str()) + .map(LitKind::Char) + .map_err(|_| LitError::LexerError); + } // There are some valid suffixes for integer and float literals, // so all the handling is done internally. @@ -56,11 +62,9 @@ impl LitKind { let symbol = if s.contains(&['\\', '\r'][..]) { let mut buf = String::with_capacity(s.len()); let mut error = Ok(()); - unescape_str(&s, &mut |_, unescaped_char| { - match unescaped_char { - Ok(c) => buf.push(c), - Err(_) => error = Err(LitError::LexerError), - } + unescape_str(&s, &mut |_, unescaped_char| match unescaped_char { + Ok(c) => buf.push(c), + Err(_) => error = Err(LitError::LexerError), }); error?; Symbol::intern(&buf) @@ -75,11 +79,9 @@ impl LitKind { let symbol = if s.contains('\r') { let mut buf = String::with_capacity(s.len()); let mut error = Ok(()); - unescape_raw_str(&s, &mut |_, unescaped_char| { - match unescaped_char { - Ok(c) => buf.push(c), - Err(_) => error = Err(LitError::LexerError), - } + unescape_raw_str(&s, &mut |_, unescaped_char| match unescaped_char { + Ok(c) => buf.push(c), + Err(_) => error = Err(LitError::LexerError), }); error?; buf.shrink_to_fit(); @@ -93,11 +95,9 @@ impl LitKind { let s = symbol.as_str(); let mut buf = Vec::with_capacity(s.len()); let mut error = Ok(()); - unescape_byte_str(&s, &mut |_, unescaped_byte| { - match unescaped_byte { - Ok(c) => buf.push(c), - Err(_) => error = Err(LitError::LexerError), - } + unescape_byte_str(&s, &mut |_, unescaped_byte| match unescaped_byte { + Ok(c) => buf.push(c), + Err(_) => error = Err(LitError::LexerError), }); error?; buf.shrink_to_fit(); @@ -108,11 +108,9 @@ impl LitKind { let bytes = if s.contains('\r') { let mut buf = Vec::with_capacity(s.len()); let mut error = Ok(()); - unescape_raw_byte_str(&s, &mut |_, unescaped_byte| { - match unescaped_byte { - Ok(c) => buf.push(c), - Err(_) => error = Err(LitError::LexerError), - } + unescape_raw_byte_str(&s, &mut |_, unescaped_byte| match unescaped_byte { + Ok(c) => buf.push(c), + Err(_) => error = Err(LitError::LexerError), }); error?; buf.shrink_to_fit(); @@ -122,7 +120,7 @@ impl LitKind { }; LitKind::ByteStr(Lrc::new(bytes)) - }, + } token::Err => LitKind::Err(symbol), }) } @@ -139,12 +137,14 @@ impl LitKind { let symbol = if s == escaped { symbol } else { Symbol::intern(&escaped) }; (token::Str, symbol, None) } - LitKind::Str(symbol, ast::StrStyle::Raw(n)) => { - (token::StrRaw(n), symbol, None) - } + LitKind::Str(symbol, ast::StrStyle::Raw(n)) => (token::StrRaw(n), symbol, None), LitKind::ByteStr(ref bytes) => { - let string = bytes.iter().cloned().flat_map(ascii::escape_default) - .map(Into::<char>::into).collect::<String>(); + let string = bytes + .iter() + .cloned() + .flat_map(ascii::escape_default) + .map(Into::<char>::into) + .collect::<String>(); (token::ByteStr, Symbol::intern(&string), None) } LitKind::Byte(byte) => { @@ -174,9 +174,7 @@ impl LitKind { let symbol = if value { kw::True } else { kw::False }; (token::Bool, symbol, None) } - LitKind::Err(symbol) => { - (token::Err, symbol, None) - } + LitKind::Err(symbol) => (token::Err, symbol, None), }; token::Lit::new(kind, symbol, suffix) @@ -192,10 +190,10 @@ impl Lit { /// Converts arbitrary token into an AST literal. pub fn from_token(token: &Token) -> Result<Lit, LitError> { let lit = match token.kind { - token::Ident(name, false) if name.is_bool_lit() => - token::Lit::new(token::Bool, name, None), - token::Literal(lit) => - lit, + token::Ident(name, false) if name.is_bool_lit() => { + token::Lit::new(token::Bool, name, None) + } + token::Literal(lit) => lit, token::Interpolated(ref nt) => { if let token::NtExpr(expr) | token::NtLiteral(expr) = &**nt { if let ast::ExprKind::Lit(lit) = &expr.kind { @@ -204,7 +202,7 @@ impl Lit { } return Err(LitError::NotLiteral); } - _ => return Err(LitError::NotLiteral) + _ => return Err(LitError::NotLiteral), }; Lit::from_lit_token(lit, token.span) @@ -238,19 +236,25 @@ fn strip_underscores(symbol: Symbol) -> Symbol { symbol } -fn filtered_float_lit(symbol: Symbol, suffix: Option<Symbol>, base: u32) - -> Result<LitKind, LitError> { +fn filtered_float_lit( + symbol: Symbol, + suffix: Option<Symbol>, + base: u32, +) -> Result<LitKind, LitError> { debug!("filtered_float_lit: {:?}, {:?}, {:?}", symbol, suffix, base); if base != 10 { return Err(LitError::NonDecimalFloat(base)); } Ok(match suffix { - Some(suf) => LitKind::Float(symbol, ast::LitFloatType::Suffixed(match suf { - sym::f32 => ast::FloatTy::F32, - sym::f64 => ast::FloatTy::F64, - _ => return Err(LitError::InvalidFloatSuffix), - })), - None => LitKind::Float(symbol, ast::LitFloatType::Unsuffixed) + Some(suf) => LitKind::Float( + symbol, + ast::LitFloatType::Suffixed(match suf { + sym::f32 => ast::FloatTy::F32, + sym::f64 => ast::FloatTy::F64, + _ => return Err(LitError::InvalidFloatSuffix), + }), + ), + None => LitKind::Float(symbol, ast::LitFloatType::Unsuffixed), }) } @@ -274,13 +278,13 @@ fn integer_lit(symbol: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitErr let ty = match suffix { Some(suf) => match suf { sym::isize => ast::LitIntType::Signed(ast::IntTy::Isize), - sym::i8 => ast::LitIntType::Signed(ast::IntTy::I8), + sym::i8 => ast::LitIntType::Signed(ast::IntTy::I8), sym::i16 => ast::LitIntType::Signed(ast::IntTy::I16), sym::i32 => ast::LitIntType::Signed(ast::IntTy::I32), sym::i64 => ast::LitIntType::Signed(ast::IntTy::I64), sym::i128 => ast::LitIntType::Signed(ast::IntTy::I128), sym::usize => ast::LitIntType::Unsigned(ast::UintTy::Usize), - sym::u8 => ast::LitIntType::Unsigned(ast::UintTy::U8), + sym::u8 => ast::LitIntType::Unsigned(ast::UintTy::U8), sym::u16 => ast::LitIntType::Unsigned(ast::UintTy::U16), sym::u32 => ast::LitIntType::Unsigned(ast::UintTy::U32), sym::u64 => ast::LitIntType::Unsigned(ast::UintTy::U64), @@ -289,11 +293,11 @@ fn integer_lit(symbol: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitErr // `fxxx` looks more like an invalid float literal than invalid integer literal. _ if suf.as_str().starts_with('f') => return filtered_float_lit(symbol, suffix, base), _ => return Err(LitError::InvalidIntSuffix), - } - _ => ast::LitIntType::Unsuffixed + }, + _ => ast::LitIntType::Unsuffixed, }; - let s = &s[if base != 10 { 2 } else { 0 } ..]; + let s = &s[if base != 10 { 2 } else { 0 }..]; u128::from_str_radix(s, base).map(|i| LitKind::Int(i, ty)).map_err(|_| { // Small bases are lexed as if they were base 10, e.g, the string // might be `0b10201`. This will cause the conversion above to fail, diff --git a/src/libsyntax/util/map_in_place.rs b/src/libsyntax/util/map_in_place.rs index 5724b540a0d..5dd9fc6e8bc 100644 --- a/src/libsyntax/util/map_in_place.rs +++ b/src/libsyntax/util/map_in_place.rs @@ -1,20 +1,25 @@ -use std::ptr; use smallvec::{Array, SmallVec}; +use std::ptr; pub trait MapInPlace<T>: Sized { - fn map_in_place<F>(&mut self, mut f: F) where F: FnMut(T) -> T { + fn map_in_place<F>(&mut self, mut f: F) + where + F: FnMut(T) -> T, + { self.flat_map_in_place(|e| Some(f(e))) } fn flat_map_in_place<F, I>(&mut self, f: F) - where F: FnMut(T) -> I, - I: IntoIterator<Item=T>; + where + F: FnMut(T) -> I, + I: IntoIterator<Item = T>; } impl<T> MapInPlace<T> for Vec<T> { fn flat_map_in_place<F, I>(&mut self, mut f: F) - where F: FnMut(T) -> I, - I: IntoIterator<Item=T> + where + F: FnMut(T) -> I, + I: IntoIterator<Item = T>, { let mut read_i = 0; let mut write_i = 0; @@ -58,8 +63,9 @@ impl<T> MapInPlace<T> for Vec<T> { impl<T, A: Array<Item = T>> MapInPlace<T> for SmallVec<A> { fn flat_map_in_place<F, I>(&mut self, mut f: F) - where F: FnMut(T) -> I, - I: IntoIterator<Item=T> + where + F: FnMut(T) -> I, + I: IntoIterator<Item = T>, { let mut read_i = 0; let mut write_i = 0; diff --git a/src/libsyntax/util/node_count.rs b/src/libsyntax/util/node_count.rs index 3db9955d304..e768ab4c648 100644 --- a/src/libsyntax/util/node_count.rs +++ b/src/libsyntax/util/node_count.rs @@ -1,7 +1,7 @@ // Simply gives a rought count of the number of nodes in an AST. -use crate::visit::*; use crate::ast::*; +use crate::visit::*; use syntax_pos::Span; pub struct NodeCounter { @@ -10,9 +10,7 @@ pub struct NodeCounter { impl NodeCounter { pub fn new() -> NodeCounter { - NodeCounter { - count: 0, - } + NodeCounter { count: 0 } } } @@ -97,8 +95,13 @@ impl<'ast> Visitor<'ast> for NodeCounter { self.count += 1; walk_struct_field(self, s) } - fn visit_enum_def(&mut self, enum_definition: &EnumDef, - generics: &Generics, item_id: NodeId, _: Span) { + fn visit_enum_def( + &mut self, + enum_definition: &EnumDef, + generics: &Generics, + item_id: NodeId, + _: Span, + ) { self.count += 1; walk_enum_def(self, enum_definition, generics, item_id) } diff --git a/src/libsyntax/util/parser.rs b/src/libsyntax/util/parser.rs index df72fdc8014..88e3d8daf70 100644 --- a/src/libsyntax/util/parser.rs +++ b/src/libsyntax/util/parser.rs @@ -1,6 +1,6 @@ -use crate::token::{self, Token, BinOpToken}; -use crate::symbol::kw; use crate::ast::{self, BinOpKind}; +use crate::symbol::kw; +use crate::token::{self, BinOpToken, Token}; /// Associative operator with precedence. /// @@ -64,7 +64,7 @@ pub enum Fixity { /// The operator is right-associative Right, /// The operator is not associative - None + None, } impl AssocOp { @@ -100,7 +100,7 @@ impl AssocOp { // `<-` should probably be `< -` token::LArrow => Some(Less), _ if t.is_keyword(kw::As) => Some(As), - _ => None + _ => None, } } @@ -125,7 +125,7 @@ impl AssocOp { BinOpKind::BitXor => BitXor, BinOpKind::BitOr => BitOr, BinOpKind::And => LAnd, - BinOpKind::Or => LOr + BinOpKind::Or => LOr, } } @@ -154,10 +154,10 @@ impl AssocOp { // NOTE: it is a bug to have an operators that has same precedence but different fixities! match *self { Assign | AssignOp(_) => Fixity::Right, - As | Multiply | Divide | Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd | - BitXor | BitOr | Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual | - LAnd | LOr | Colon => Fixity::Left, - DotDot | DotDotEq => Fixity::None + As | Multiply | Divide | Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd + | BitXor | BitOr | Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual + | LAnd | LOr | Colon => Fixity::Left, + DotDot | DotDotEq => Fixity::None, } } @@ -165,9 +165,9 @@ impl AssocOp { use AssocOp::*; match *self { Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual => true, - Assign | AssignOp(_) | As | Multiply | Divide | Modulus | Add | - Subtract | ShiftLeft | ShiftRight | BitAnd | BitXor | BitOr | LAnd | LOr | - DotDot | DotDotEq | Colon => false + Assign | AssignOp(_) | As | Multiply | Divide | Modulus | Add | Subtract + | ShiftLeft | ShiftRight | BitAnd | BitXor | BitOr | LAnd | LOr | DotDot | DotDotEq + | Colon => false, } } @@ -175,9 +175,9 @@ impl AssocOp { use AssocOp::*; match *self { Assign | AssignOp(_) => true, - Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual | As | Multiply | Divide | - Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd | BitXor | BitOr | LAnd | - LOr | DotDot | DotDotEq | Colon => false + Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual | As | Multiply + | Divide | Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd | BitXor + | BitOr | LAnd | LOr | DotDot | DotDotEq | Colon => false, } } @@ -202,7 +202,7 @@ impl AssocOp { BitOr => Some(BinOpKind::BitOr), LAnd => Some(BinOpKind::And), LOr => Some(BinOpKind::Or), - Assign | AssignOp(_) | As | DotDot | DotDotEq | Colon => None + Assign | AssignOp(_) | As | DotDot | DotDotEq | Colon => None, } } @@ -378,18 +378,18 @@ pub fn contains_exterior_struct_lit(value: &ast::Expr) -> bool { match value.kind { ast::ExprKind::Struct(..) => true, - ast::ExprKind::Assign(ref lhs, ref rhs) | - ast::ExprKind::AssignOp(_, ref lhs, ref rhs) | - ast::ExprKind::Binary(_, ref lhs, ref rhs) => { + ast::ExprKind::Assign(ref lhs, ref rhs) + | ast::ExprKind::AssignOp(_, ref lhs, ref rhs) + | ast::ExprKind::Binary(_, ref lhs, ref rhs) => { // X { y: 1 } + X { y: 2 } contains_exterior_struct_lit(&lhs) || contains_exterior_struct_lit(&rhs) } - ast::ExprKind::Await(ref x) | - ast::ExprKind::Unary(_, ref x) | - ast::ExprKind::Cast(ref x, _) | - ast::ExprKind::Type(ref x, _) | - ast::ExprKind::Field(ref x, _) | - ast::ExprKind::Index(ref x, _) => { + ast::ExprKind::Await(ref x) + | ast::ExprKind::Unary(_, ref x) + | ast::ExprKind::Cast(ref x, _) + | ast::ExprKind::Type(ref x, _) + | ast::ExprKind::Field(ref x, _) + | ast::ExprKind::Index(ref x, _) => { // &X { y: 1 }, X { y: 1 }.y contains_exterior_struct_lit(&x) } diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 51e7fa1eb38..d6573a06647 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -15,7 +15,7 @@ use crate::ast::*; use crate::token::Token; -use crate::tokenstream::{TokenTree, TokenStream}; +use crate::tokenstream::{TokenStream, TokenTree}; use syntax_pos::Span; @@ -60,33 +60,67 @@ pub trait Visitor<'ast>: Sized { fn visit_mod(&mut self, m: &'ast Mod, _s: Span, _attrs: &[Attribute], _n: NodeId) { walk_mod(self, m); } - fn visit_foreign_item(&mut self, i: &'ast ForeignItem) { walk_foreign_item(self, i) } - fn visit_global_asm(&mut self, ga: &'ast GlobalAsm) { walk_global_asm(self, ga) } - fn visit_item(&mut self, i: &'ast Item) { walk_item(self, i) } - fn visit_local(&mut self, l: &'ast Local) { walk_local(self, l) } - fn visit_block(&mut self, b: &'ast Block) { walk_block(self, b) } - fn visit_stmt(&mut self, s: &'ast Stmt) { walk_stmt(self, s) } - fn visit_param(&mut self, param: &'ast Param) { walk_param(self, param) } - fn visit_arm(&mut self, a: &'ast Arm) { walk_arm(self, a) } - fn visit_pat(&mut self, p: &'ast Pat) { walk_pat(self, p) } - fn visit_anon_const(&mut self, c: &'ast AnonConst) { walk_anon_const(self, c) } - fn visit_expr(&mut self, ex: &'ast Expr) { walk_expr(self, ex) } - fn visit_expr_post(&mut self, _ex: &'ast Expr) { } - fn visit_ty(&mut self, t: &'ast Ty) { walk_ty(self, t) } + fn visit_foreign_item(&mut self, i: &'ast ForeignItem) { + walk_foreign_item(self, i) + } + fn visit_global_asm(&mut self, ga: &'ast GlobalAsm) { + walk_global_asm(self, ga) + } + fn visit_item(&mut self, i: &'ast Item) { + walk_item(self, i) + } + fn visit_local(&mut self, l: &'ast Local) { + walk_local(self, l) + } + fn visit_block(&mut self, b: &'ast Block) { + walk_block(self, b) + } + fn visit_stmt(&mut self, s: &'ast Stmt) { + walk_stmt(self, s) + } + fn visit_param(&mut self, param: &'ast Param) { + walk_param(self, param) + } + fn visit_arm(&mut self, a: &'ast Arm) { + walk_arm(self, a) + } + fn visit_pat(&mut self, p: &'ast Pat) { + walk_pat(self, p) + } + fn visit_anon_const(&mut self, c: &'ast AnonConst) { + walk_anon_const(self, c) + } + fn visit_expr(&mut self, ex: &'ast Expr) { + walk_expr(self, ex) + } + fn visit_expr_post(&mut self, _ex: &'ast Expr) {} + fn visit_ty(&mut self, t: &'ast Ty) { + walk_ty(self, t) + } fn visit_generic_param(&mut self, param: &'ast GenericParam) { walk_generic_param(self, param) } - fn visit_generics(&mut self, g: &'ast Generics) { walk_generics(self, g) } + fn visit_generics(&mut self, g: &'ast Generics) { + walk_generics(self, g) + } fn visit_where_predicate(&mut self, p: &'ast WherePredicate) { walk_where_predicate(self, p) } fn visit_fn(&mut self, fk: FnKind<'ast>, fd: &'ast FnDecl, s: Span, _: NodeId) { walk_fn(self, fk, fd, s) } - fn visit_trait_item(&mut self, i: &'ast AssocItem) { walk_trait_item(self, i) } - fn visit_impl_item(&mut self, i: &'ast AssocItem) { walk_impl_item(self, i) } - fn visit_assoc_item(&mut self, i: &'ast AssocItem) { walk_assoc_item(self, i) } - fn visit_trait_ref(&mut self, t: &'ast TraitRef) { walk_trait_ref(self, t) } + fn visit_trait_item(&mut self, i: &'ast AssocItem) { + walk_trait_item(self, i) + } + fn visit_impl_item(&mut self, i: &'ast AssocItem) { + walk_impl_item(self, i) + } + fn visit_assoc_item(&mut self, i: &'ast AssocItem) { + walk_assoc_item(self, i) + } + fn visit_trait_ref(&mut self, t: &'ast TraitRef) { + walk_trait_ref(self, t) + } fn visit_param_bound(&mut self, bounds: &'ast GenericBound) { walk_param_bound(self, bounds) } @@ -96,9 +130,16 @@ pub trait Visitor<'ast>: Sized { fn visit_variant_data(&mut self, s: &'ast VariantData) { walk_struct_def(self, s) } - fn visit_struct_field(&mut self, s: &'ast StructField) { walk_struct_field(self, s) } - fn visit_enum_def(&mut self, enum_definition: &'ast EnumDef, - generics: &'ast Generics, item_id: NodeId, _: Span) { + fn visit_struct_field(&mut self, s: &'ast StructField) { + walk_struct_field(self, s) + } + fn visit_enum_def( + &mut self, + enum_definition: &'ast EnumDef, + generics: &'ast Generics, + item_id: NodeId, + _: Span, + ) { walk_enum_def(self, enum_definition, generics, item_id) } fn visit_variant(&mut self, v: &'ast Variant) { @@ -215,10 +256,12 @@ pub fn walk_lifetime<'a, V: Visitor<'a>>(visitor: &mut V, lifetime: &'a Lifetime visitor.visit_ident(lifetime.ident); } -pub fn walk_poly_trait_ref<'a, V>(visitor: &mut V, - trait_ref: &'a PolyTraitRef, - _: &TraitBoundModifier) - where V: Visitor<'a>, +pub fn walk_poly_trait_ref<'a, V>( + visitor: &mut V, + trait_ref: &'a PolyTraitRef, + _: &TraitBoundModifier, +) where + V: Visitor<'a>, { walk_list!(visitor, visit_generic_param, &trait_ref.bound_generic_params); visitor.visit_trait_ref(&trait_ref.trait_ref); @@ -237,25 +280,22 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) { visitor.visit_name(item.span, orig_name); } } - ItemKind::Use(ref use_tree) => { - visitor.visit_use_tree(use_tree, item.id, false) - } - ItemKind::Static(ref typ, _, ref expr) | - ItemKind::Const(ref typ, ref expr) => { + ItemKind::Use(ref use_tree) => visitor.visit_use_tree(use_tree, item.id, false), + ItemKind::Static(ref typ, _, ref expr) | ItemKind::Const(ref typ, ref expr) => { visitor.visit_ty(typ); visitor.visit_expr(expr); } ItemKind::Fn(ref sig, ref generics, ref body) => { visitor.visit_generics(generics); visitor.visit_fn_header(&sig.header); - visitor.visit_fn(FnKind::ItemFn(item.ident, &sig.header, &item.vis, body), - &sig.decl, - item.span, - item.id) - } - ItemKind::Mod(ref module) => { - visitor.visit_mod(module, item.span, &item.attrs, item.id) - } + visitor.visit_fn( + FnKind::ItemFn(item.ident, &sig.header, &item.vis, body), + &sig.decl, + item.span, + item.id, + ) + } + ItemKind::Mod(ref module) => visitor.visit_mod(module, item.span, &item.attrs, item.id), ItemKind::ForeignMod(ref foreign_module) => { walk_list!(visitor, visit_foreign_item, &foreign_module.items); } @@ -268,18 +308,14 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) { visitor.visit_generics(generics); visitor.visit_enum_def(enum_definition, generics, item.id, item.span) } - ItemKind::Impl(_, _, _, - ref generics, - ref opt_trait_reference, - ref typ, - ref impl_items) => { + ItemKind::Impl(_, _, _, ref generics, ref opt_trait_reference, ref typ, ref impl_items) => { visitor.visit_generics(generics); walk_list!(visitor, visit_trait_ref, opt_trait_reference); visitor.visit_ty(typ); walk_list!(visitor, visit_impl_item, impl_items); } - ItemKind::Struct(ref struct_definition, ref generics) | - ItemKind::Union(ref struct_definition, ref generics) => { + ItemKind::Struct(ref struct_definition, ref generics) + | ItemKind::Union(ref struct_definition, ref generics) => { visitor.visit_generics(generics); visitor.visit_variant_data(struct_definition); } @@ -308,7 +344,8 @@ pub fn walk_enum_def<'a, V: Visitor<'a>>( } pub fn walk_variant<'a, V: Visitor<'a>>(visitor: &mut V, variant: &'a Variant) - where V: Visitor<'a>, +where + V: Visitor<'a>, { visitor.visit_ident(variant.ident); visitor.visit_vis(&variant.vis); @@ -331,12 +368,8 @@ pub fn walk_field_pattern<'a, V: Visitor<'a>>(visitor: &mut V, fp: &'a FieldPat) pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) { match typ.kind { - TyKind::Slice(ref ty) | TyKind::Paren(ref ty) => { - visitor.visit_ty(ty) - } - TyKind::Ptr(ref mutable_type) => { - visitor.visit_ty(&mutable_type.ty) - } + TyKind::Slice(ref ty) | TyKind::Paren(ref ty) => visitor.visit_ty(ty), + TyKind::Ptr(ref mutable_type) => visitor.visit_ty(&mutable_type.ty), TyKind::Rptr(ref opt_lifetime, ref mutable_type) => { walk_list!(visitor, visit_lifetime, opt_lifetime); visitor.visit_ty(&mutable_type.ty) @@ -358,19 +391,13 @@ pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) { visitor.visit_ty(ty); visitor.visit_anon_const(length) } - TyKind::TraitObject(ref bounds, ..) | - TyKind::ImplTrait(_, ref bounds) => { + TyKind::TraitObject(ref bounds, ..) | TyKind::ImplTrait(_, ref bounds) => { walk_list!(visitor, visit_param_bound, bounds); } - TyKind::Typeof(ref expression) => { - visitor.visit_anon_const(expression) - } + TyKind::Typeof(ref expression) => visitor.visit_anon_const(expression), TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err => {} - TyKind::Mac(ref mac) => { - visitor.visit_mac(mac) - } - TyKind::Never | - TyKind::CVarArgs => {} + TyKind::Mac(ref mac) => visitor.visit_mac(mac), + TyKind::Never | TyKind::CVarArgs => {} } } @@ -380,9 +407,7 @@ pub fn walk_path<'a, V: Visitor<'a>>(visitor: &mut V, path: &'a Path) { } } -pub fn walk_use_tree<'a, V: Visitor<'a>>( - visitor: &mut V, use_tree: &'a UseTree, id: NodeId, -) { +pub fn walk_use_tree<'a, V: Visitor<'a>>(visitor: &mut V, use_tree: &'a UseTree, id: NodeId) { visitor.visit_path(&use_tree.prefix, id); match use_tree.kind { UseTreeKind::Simple(rename, ..) => { @@ -391,7 +416,7 @@ pub fn walk_use_tree<'a, V: Visitor<'a>>( visitor.visit_ident(rename); } } - UseTreeKind::Glob => {}, + UseTreeKind::Glob => {} UseTreeKind::Nested(ref use_trees) => { for &(ref nested_tree, nested_id) in use_trees { visitor.visit_use_tree(nested_tree, nested_id, true); @@ -400,19 +425,20 @@ pub fn walk_use_tree<'a, V: Visitor<'a>>( } } -pub fn walk_path_segment<'a, V: Visitor<'a>>(visitor: &mut V, - path_span: Span, - segment: &'a PathSegment) { +pub fn walk_path_segment<'a, V: Visitor<'a>>( + visitor: &mut V, + path_span: Span, + segment: &'a PathSegment, +) { visitor.visit_ident(segment.ident); if let Some(ref args) = segment.args { visitor.visit_generic_args(path_span, args); } } -pub fn walk_generic_args<'a, V>(visitor: &mut V, - _path_span: Span, - generic_args: &'a GenericArgs) - where V: Visitor<'a>, +pub fn walk_generic_args<'a, V>(visitor: &mut V, _path_span: Span, generic_args: &'a GenericArgs) +where + V: Visitor<'a>, { match *generic_args { GenericArgs::AngleBracketed(ref data) => { @@ -426,8 +452,10 @@ pub fn walk_generic_args<'a, V>(visitor: &mut V, } } -pub fn walk_assoc_ty_constraint<'a, V: Visitor<'a>>(visitor: &mut V, - constraint: &'a AssocTyConstraint) { +pub fn walk_assoc_ty_constraint<'a, V: Visitor<'a>>( + visitor: &mut V, + constraint: &'a AssocTyConstraint, +) { visitor.visit_ident(constraint.ident); match constraint.kind { AssocTyConstraintKind::Equality { ref ty } => { @@ -455,11 +483,9 @@ pub fn walk_pat<'a, V: Visitor<'a>>(visitor: &mut V, pattern: &'a Pat) { visitor.visit_path(path, pattern.id); walk_list!(visitor, visit_field_pattern, fields); } - PatKind::Box(ref subpattern) | - PatKind::Ref(ref subpattern, _) | - PatKind::Paren(ref subpattern) => { - visitor.visit_pat(subpattern) - } + PatKind::Box(ref subpattern) + | PatKind::Ref(ref subpattern, _) + | PatKind::Paren(ref subpattern) => visitor.visit_pat(subpattern), PatKind::Ident(_, ident, ref optional_subpattern) => { visitor.visit_ident(ident); walk_list!(visitor, visit_pat, optional_subpattern); @@ -469,10 +495,8 @@ pub fn walk_pat<'a, V: Visitor<'a>>(visitor: &mut V, pattern: &'a Pat) { visitor.visit_expr(lower_bound); visitor.visit_expr(upper_bound); } - PatKind::Wild | PatKind::Rest => {}, - PatKind::Tuple(ref elems) - | PatKind::Slice(ref elems) - | PatKind::Or(ref elems) => { + PatKind::Wild | PatKind::Rest => {} + PatKind::Tuple(ref elems) | PatKind::Slice(ref elems) | PatKind::Or(ref elems) => { walk_list!(visitor, visit_pat, elems); } PatKind::Mac(ref mac) => visitor.visit_mac(mac), @@ -525,23 +549,23 @@ pub fn walk_generics<'a, V: Visitor<'a>>(visitor: &mut V, generics: &'a Generics pub fn walk_where_predicate<'a, V: Visitor<'a>>(visitor: &mut V, predicate: &'a WherePredicate) { match *predicate { - WherePredicate::BoundPredicate(WhereBoundPredicate{ref bounded_ty, - ref bounds, - ref bound_generic_params, - ..}) => { + WherePredicate::BoundPredicate(WhereBoundPredicate { + ref bounded_ty, + ref bounds, + ref bound_generic_params, + .. + }) => { visitor.visit_ty(bounded_ty); walk_list!(visitor, visit_param_bound, bounds); walk_list!(visitor, visit_generic_param, bound_generic_params); } - WherePredicate::RegionPredicate(WhereRegionPredicate{ref lifetime, - ref bounds, - ..}) => { + WherePredicate::RegionPredicate(WhereRegionPredicate { + ref lifetime, ref bounds, .. + }) => { visitor.visit_lifetime(lifetime); walk_list!(visitor, visit_param_bound, bounds); } - WherePredicate::EqPredicate(WhereEqPredicate{ref lhs_ty, - ref rhs_ty, - ..}) => { + WherePredicate::EqPredicate(WhereEqPredicate { ref lhs_ty, ref rhs_ty, .. }) => { visitor.visit_ty(lhs_ty); visitor.visit_ty(rhs_ty); } @@ -562,7 +586,8 @@ pub fn walk_fn_decl<'a, V: Visitor<'a>>(visitor: &mut V, function_declaration: & } pub fn walk_fn<'a, V>(visitor: &mut V, kind: FnKind<'a>, declaration: &'a FnDecl, _span: Span) - where V: Visitor<'a>, +where + V: Visitor<'a>, { match kind { FnKind::ItemFn(_, header, _, body) => { @@ -605,8 +630,12 @@ pub fn walk_assoc_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a AssocItem) walk_fn_decl(visitor, &sig.decl); } AssocItemKind::Fn(ref sig, Some(ref body)) => { - visitor.visit_fn(FnKind::Method(item.ident, sig, &item.vis, body), - &sig.decl, item.span, item.id); + visitor.visit_fn( + FnKind::Method(item.ident, sig, &item.vis, body), + &sig.decl, + item.span, + item.id, + ); } AssocItemKind::TyAlias(ref bounds, ref ty) => { walk_list!(visitor, visit_param_bound, bounds); @@ -664,9 +693,7 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) { walk_list!(visitor, visit_attribute, expression.attrs.iter()); match expression.kind { - ExprKind::Box(ref subexpression) => { - visitor.visit_expr(subexpression) - } + ExprKind::Box(ref subexpression) => visitor.visit_expr(subexpression), ExprKind::Array(ref subexpressions) => { walk_list!(visitor, visit_expr, subexpressions); } @@ -729,12 +756,8 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) { visitor.visit_expr(subexpression); walk_list!(visitor, visit_arm, arms); } - ExprKind::Closure(_, _, _, ref function_declaration, ref body, _decl_span) => { - visitor.visit_fn(FnKind::Closure(body), - function_declaration, - expression.span, - expression.id) - } + ExprKind::Closure(_, _, _, ref function_declaration, ref body, _decl_span) => visitor + .visit_fn(FnKind::Closure(body), function_declaration, expression.span, expression.id), ExprKind::Block(ref block, ref opt_label) => { walk_list!(visitor, visit_label, opt_label); visitor.visit_block(block); @@ -780,9 +803,7 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) { walk_list!(visitor, visit_expr, optional_expression); } ExprKind::Mac(ref mac) => visitor.visit_mac(mac), - ExprKind::Paren(ref subexpression) => { - visitor.visit_expr(subexpression) - } + ExprKind::Paren(ref subexpression) => visitor.visit_expr(subexpression), ExprKind::InlineAsm(ref ia) => { for &(_, ref input) in &ia.inputs { visitor.visit_expr(input) @@ -794,12 +815,8 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) { ExprKind::Yield(ref optional_expression) => { walk_list!(visitor, visit_expr, optional_expression); } - ExprKind::Try(ref subexpression) => { - visitor.visit_expr(subexpression) - } - ExprKind::TryBlock(ref body) => { - visitor.visit_block(body) - } + ExprKind::Try(ref subexpression) => visitor.visit_expr(subexpression), + ExprKind::TryBlock(ref body) => visitor.visit_block(body), ExprKind::Lit(_) | ExprKind::Err => {} } |