Run rustfmt on src
diff --git a/src/aster/generics.rs b/src/aster/generics.rs
index 8feb87c..caee562 100644
--- a/src/aster/generics.rs
+++ b/src/aster/generics.rs
@@ -169,9 +169,7 @@
}
pub fn strip_bounds(self) -> Self {
- self.strip_lifetimes()
- .strip_ty_params()
- .strip_predicates()
+ self.strip_lifetimes().strip_ty_params().strip_predicates()
}
pub fn strip_lifetimes(mut self) -> Self {
@@ -195,10 +193,10 @@
pub fn build(self) -> F::Result {
self.callback.invoke(Generics {
- lifetimes: self.lifetimes,
- ty_params: self.ty_params,
- where_clause: WhereClause { predicates: self.predicates },
- })
+ lifetimes: self.lifetimes,
+ ty_params: self.ty_params,
+ where_clause: WhereClause { predicates: self.predicates },
+ })
}
}
diff --git a/src/aster/lifetime.rs b/src/aster/lifetime.rs
index 49df4a0..3bdf372 100644
--- a/src/aster/lifetime.rs
+++ b/src/aster/lifetime.rs
@@ -95,9 +95,9 @@
pub fn build(self) -> F::Result {
self.callback.invoke(LifetimeDef {
- attrs: vec![],
- lifetime: self.lifetime,
- bounds: self.bounds,
- })
+ attrs: vec![],
+ lifetime: self.lifetime,
+ bounds: self.bounds,
+ })
}
}
diff --git a/src/aster/path.rs b/src/aster/path.rs
index a0fb314..e53b142 100644
--- a/src/aster/path.rs
+++ b/src/aster/path.rs
@@ -139,9 +139,9 @@
pub fn build(self) -> F::Result {
self.callback.invoke(Path {
- global: self.global,
- segments: self.segments,
- })
+ global: self.global,
+ segments: self.segments,
+ })
}
}
@@ -181,16 +181,12 @@
pub fn with_generics(self, generics: Generics) -> Self {
// Strip off the bounds.
- let lifetimes = generics.lifetimes
- .iter()
- .map(|lifetime_def| lifetime_def.lifetime.clone());
+ let lifetimes = generics.lifetimes.iter().map(|lifetime_def| lifetime_def.lifetime.clone());
- let tys = generics.ty_params
- .iter()
- .map(|ty_param| TyBuilder::new().id(ty_param.ident.clone()));
+ let tys =
+ generics.ty_params.iter().map(|ty_param| TyBuilder::new().id(ty_param.ident.clone()));
- self.with_lifetimes(lifetimes)
- .with_tys(tys)
+ self.with_lifetimes(lifetimes).with_tys(tys)
}
pub fn with_lifetimes<I, L>(mut self, iter: I) -> Self
@@ -241,9 +237,9 @@
where T: ToIdent
{
TyBuilder::with_callback(TypeBindingBuilder {
- id: id.to_ident(),
- builder: self,
- })
+ id: id.to_ident(),
+ builder: self,
+ })
}
pub fn no_return(self) -> F::Result {
@@ -263,9 +259,9 @@
let parameters = PathParameters::Parenthesized(data);
self.callback.invoke(PathSegment {
- ident: self.id,
- parameters: parameters,
- })
+ ident: self.id,
+ parameters: parameters,
+ })
}
pub fn build(self) -> F::Result {
@@ -278,9 +274,9 @@
let parameters = PathParameters::AngleBracketed(data);
self.callback.invoke(PathSegment {
- ident: self.id,
- parameters: parameters,
- })
+ ident: self.id,
+ parameters: parameters,
+ })
}
}
@@ -310,9 +306,9 @@
let id = self.id;
self.builder.with_binding(TypeBinding {
- ident: id,
- ty: ty,
- })
+ ident: id,
+ ty: ty,
+ })
}
}
diff --git a/src/aster/ty.rs b/src/aster/ty.rs
index 127b164..7dff3b4 100644
--- a/src/aster/ty.rs
+++ b/src/aster/ty.rs
@@ -410,9 +410,7 @@
}
pub fn with_generics(self, generics: Generics) -> Self {
- self.with_lifetimes(generics.lifetimes
- .into_iter()
- .map(|def| def.lifetime))
+ self.with_lifetimes(generics.lifetimes.into_iter().map(|def| def.lifetime))
}
pub fn with_lifetimes<I, L>(mut self, lifetimes: I) -> Self
diff --git a/src/aster/ty_param.rs b/src/aster/ty_param.rs
index 2836203..d8d13d1 100644
--- a/src/aster/ty_param.rs
+++ b/src/aster/ty_param.rs
@@ -87,11 +87,11 @@
pub fn build(self) -> F::Result {
self.callback.invoke(TyParam {
- attrs: vec![],
- ident: self.id,
- bounds: self.bounds,
- default: self.default,
- })
+ attrs: vec![],
+ ident: self.id,
+ bounds: self.bounds,
+ default: self.default,
+ })
}
}
@@ -245,9 +245,9 @@
pub fn build(self) -> F::Result {
self.callback.invoke(PolyTraitRef {
- bound_lifetimes: self.lifetimes,
- trait_ref: self.trait_ref,
- })
+ bound_lifetimes: self.lifetimes,
+ trait_ref: self.trait_ref,
+ })
}
}
diff --git a/src/escape.rs b/src/escape.rs
index 80c3def..c17a158 100644
--- a/src/escape.rs
+++ b/src/escape.rs
@@ -281,12 +281,14 @@
fn test_cooked_string() {
let input = "\\x62 \\\n \\u{7} \\u{64} \\u{bf5} \\u{12ba} \\u{1F395} \\u{102345}\"";
let expected = "\x62 \u{7} \u{64} \u{bf5} \u{12ba} \u{1F395} \u{102345}";
- assert_eq!(cooked_string(input), IResult::Done("\"", expected.to_string()));
+ assert_eq!(cooked_string(input),
+ IResult::Done("\"", expected.to_string()));
}
#[test]
fn test_cooked_byte_string() {
let input = "\\x62 \\\n \\xEF\"";
let expected = b"\x62 \xEF";
- assert_eq!(cooked_byte_string(input), IResult::Done("\"", expected.to_vec()));
+ assert_eq!(cooked_byte_string(input),
+ IResult::Done("\"", expected.to_vec()));
}
diff --git a/src/expr.rs b/src/expr.rs
index cde988e..69a3389 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -1406,9 +1406,9 @@
if qself.position > 0 {
tokens.append("as");
for (i, segment) in path.segments
- .iter()
- .take(qself.position)
- .enumerate() {
+ .iter()
+ .take(qself.position)
+ .enumerate() {
if i > 0 || path.global {
tokens.append("::");
}
@@ -1554,9 +1554,9 @@
if qself.position > 0 {
tokens.append("as");
for (i, segment) in path.segments
- .iter()
- .take(qself.position)
- .enumerate() {
+ .iter()
+ .take(qself.position)
+ .enumerate() {
if i > 0 || path.global {
tokens.append("::");
}
diff --git a/src/fold.rs b/src/fold.rs
index 374ff68..2874118 100644
--- a/src/fold.rs
+++ b/src/fold.rs
@@ -183,7 +183,7 @@
vis,
attrs,
generics,
- body }: DeriveInput) -> DeriveInput {
+body }: DeriveInput) -> DeriveInput{
use Body::*;
DeriveInput {
ident: folder.fold_ident(ident),
@@ -206,18 +206,18 @@
let mutable_type_ = *mutable_type;
let MutTy { ty, mutability }: MutTy = mutable_type_;
Ptr(Box::new(MutTy {
- ty: folder.fold_ty(ty),
- mutability: mutability,
- }))
+ ty: folder.fold_ty(ty),
+ mutability: mutability,
+ }))
}
Rptr(opt_lifetime, mutable_type) => {
let mutable_type_ = *mutable_type;
let MutTy { ty, mutability }: MutTy = mutable_type_;
Rptr(opt_lifetime.map(|l| folder.fold_lifetime(l)),
Box::new(MutTy {
- ty: folder.fold_ty(ty),
- mutability: mutability,
- }))
+ ty: folder.fold_ty(ty),
+ mutability: mutability,
+ }))
}
Never => Never,
Infer => Infer,
@@ -226,18 +226,18 @@
let bf_ = *bare_fn;
let BareFnTy { unsafety, abi, lifetimes, inputs, output, variadic } = bf_;
BareFn(Box::new(BareFnTy {
- unsafety: unsafety,
- abi: abi,
- lifetimes: lifetimes.lift(|l| folder.fold_lifetime_def(l)),
- inputs: inputs.lift(|v| {
- BareFnArg {
- name: v.name.map(|n| folder.fold_ident(n)),
- ty: folder.fold_ty(v.ty),
- }
- }),
- output: folder.fold_fn_ret_ty(output),
- variadic: variadic,
- }))
+ unsafety: unsafety,
+ abi: abi,
+ lifetimes: lifetimes.lift(|l| folder.fold_lifetime_def(l)),
+ inputs: inputs.lift(|v| {
+ BareFnArg {
+ name: v.name.map(|n| folder.fold_ident(n)),
+ ty: folder.fold_ty(v.ty),
+ }
+ }),
+ output: folder.fold_fn_ret_ty(output),
+ variadic: variadic,
+ }))
}
Path(maybe_qself, path) => {
Path(maybe_qself.map(|v| noop_fold_qself(folder, v)),
@@ -264,7 +264,7 @@
pub fn noop_fold_generics<F: ?Sized + Folder>(folder: &mut F,
Generics { lifetimes, ty_params, where_clause }: Generics)
- -> Generics {
+-> Generics{
use WherePredicate::*;
Generics {
lifetimes: lifetimes.lift(|l| folder.fold_lifetime_def(l)),
@@ -272,15 +272,13 @@
TyParam {
attrs: ty.attrs.lift(|a| folder.fold_attribute(a)),
ident: folder.fold_ident(ty.ident),
- bounds: ty.bounds
- .lift(|ty_pb| folder.fold_ty_param_bound(ty_pb)),
+ bounds: ty.bounds.lift(|ty_pb| folder.fold_ty_param_bound(ty_pb)),
default: ty.default.map(|v| folder.fold_ty(v)),
}
}),
where_clause: WhereClause {
- predicates: where_clause.predicates
- .lift(|p| match p {
- BoundPredicate(bound_predicate) => {
+ predicates: where_clause.predicates.lift(|p| match p {
+ BoundPredicate(bound_predicate) => {
BoundPredicate(WhereBoundPredicate {
bound_lifetimes: bound_predicate.bound_lifetimes
.lift(|l| folder.fold_lifetime_def(l)),
@@ -289,20 +287,20 @@
.lift(|ty_pb| folder.fold_ty_param_bound(ty_pb)),
})
}
- RegionPredicate(region_predicate) => {
+ RegionPredicate(region_predicate) => {
RegionPredicate(WhereRegionPredicate {
lifetime: folder.fold_lifetime(region_predicate.lifetime),
bounds: region_predicate.bounds
.lift(|b| folder.fold_lifetime(b)),
})
}
- EqPredicate(eq_predicate) => {
+ EqPredicate(eq_predicate) => {
EqPredicate(WhereEqPredicate {
lhs_ty: folder.fold_ty(eq_predicate.lhs_ty),
rhs_ty: folder.fold_ty(eq_predicate.rhs_ty),
})
}
- }),
+ }),
},
}
}
@@ -321,8 +319,7 @@
trait_ref: PolyTraitRef)
-> PolyTraitRef {
PolyTraitRef {
- bound_lifetimes: trait_ref.bound_lifetimes
- .lift(|bl| folder.fold_lifetime_def(bl)),
+ bound_lifetimes: trait_ref.bound_lifetimes.lift(|bl| folder.fold_lifetime_def(bl)),
trait_ref: folder.fold_path(trait_ref.trait_ref),
}
}
@@ -349,7 +346,7 @@
pub fn noop_fold_variant<F: ?Sized + Folder>(folder: &mut F,
Variant { ident, attrs, data, discriminant }: Variant)
- -> Variant {
+-> Variant{
Variant {
ident: folder.fold_ident(ident),
attrs: attrs.lift(|v| folder.fold_attribute(v)),
@@ -364,7 +361,7 @@
pub fn noop_fold_lifetime_def<F: ?Sized + Folder>(folder: &mut F,
LifetimeDef { attrs, lifetime, bounds }: LifetimeDef)
- -> LifetimeDef {
+-> LifetimeDef{
LifetimeDef {
attrs: attrs.lift(|x| folder.fold_attribute(x)),
lifetime: folder.fold_lifetime(lifetime),
@@ -396,17 +393,19 @@
AngleBracketed(d) => {
let AngleBracketedParameterData { lifetimes, types, bindings } = d;
AngleBracketed(AngleBracketedParameterData {
- lifetimes: lifetimes.into_iter().map(|l| folder.fold_lifetime(l)).collect(),
- types: types.lift(|ty| folder.fold_ty(ty)),
- bindings: bindings.lift(|tb| folder.fold_assoc_type_binding(tb)),
- })
+ lifetimes: lifetimes.into_iter()
+ .map(|l| folder.fold_lifetime(l))
+ .collect(),
+ types: types.lift(|ty| folder.fold_ty(ty)),
+ bindings: bindings.lift(|tb| folder.fold_assoc_type_binding(tb)),
+ })
}
Parenthesized(d) => {
let ParenthesizedParameterData { inputs, output } = d;
Parenthesized(ParenthesizedParameterData {
- inputs: inputs.lift(|i| folder.fold_ty(i)),
- output: output.map(|v| folder.fold_ty(v)),
- })
+ inputs: inputs.lift(|i| folder.fold_ty(i)),
+ output: output.map(|v| folder.fold_ty(v)),
+ })
}
}
}
@@ -469,7 +468,9 @@
}
#[cfg(not(feature = "full"))]
-fn noop_fold_other_const_expr<F: ?Sized + Folder>(_: &mut F, e: constant::Other) -> constant::Other {
+fn noop_fold_other_const_expr<F: ?Sized + Folder>(_: &mut F,
+ e: constant::Other)
+ -> constant::Other {
e
}
@@ -483,17 +484,17 @@
match tt {
Token(token) => {
Token(match token {
- Literal(lit) => Literal(folder.fold_lit(lit)),
- Ident(ident) => Ident(folder.fold_ident(ident)),
- Lifetime(ident) => Lifetime(folder.fold_ident(ident)),
- x => x,
- })
+ Literal(lit) => Literal(folder.fold_lit(lit)),
+ Ident(ident) => Ident(folder.fold_ident(ident)),
+ Lifetime(ident) => Lifetime(folder.fold_ident(ident)),
+ x => x,
+ })
}
Delimited(super::Delimited { delim, tts }) => {
Delimited(super::Delimited {
- delim: delim,
- tts: tts.lift(|v| noop_fold_tt(folder, v)),
- })
+ delim: delim,
+ tts: tts.lift(|v| noop_fold_tt(folder, v)),
+ })
}
}
}
@@ -564,9 +565,11 @@
Mod(items) => Mod(items.map(|items| items.lift(|i| folder.fold_item(i)))),
ForeignMod(super::ForeignMod { abi, items }) => {
ForeignMod(super::ForeignMod {
- abi: abi,
- items: items.lift(|foreign_item| folder.fold_foreign_item(foreign_item)),
- })
+ abi: abi,
+ items: items.lift(|foreign_item| {
+ folder.fold_foreign_item(foreign_item)
+ }),
+ })
}
Ty(ty, generics) => {
Ty(ty.lift(|ty| folder.fold_ty(ty)),
@@ -747,7 +750,7 @@
#[cfg(feature = "full")]
pub fn noop_fold_foreign_item<F: ?Sized + Folder>(folder: &mut F,
ForeignItem { ident, attrs, node, vis }: ForeignItem)
- -> ForeignItem {
+-> ForeignItem{
ForeignItem {
ident: folder.fold_ident(ident),
attrs: attrs.into_iter().map(|a| folder.fold_attribute(a)).collect(),
@@ -861,7 +864,7 @@
#[cfg(feature = "full")]
pub fn noop_fold_impl_item<F: ?Sized + Folder>(folder: &mut F,
ImplItem { ident, vis, defaultness, attrs, node }: ImplItem)
- -> ImplItem {
+-> ImplItem{
use ImplItemKind::*;
ImplItem {
ident: folder.fold_ident(ident),
@@ -878,7 +881,7 @@
}
#[cfg(feature = "full")]
-pub fn noop_fold_method_sig<F: ?Sized + Folder>(folder: &mut F, MethodSig{unsafety, constness, abi, decl, generics}:MethodSig) -> MethodSig {
+pub fn noop_fold_method_sig<F: ?Sized + Folder>(folder: &mut F, MethodSig{unsafety, constness, abi, decl, generics}:MethodSig) -> MethodSig{
MethodSig {
unsafety: unsafety,
constness: constness,
@@ -899,8 +902,10 @@
Semi(expr) => Semi(expr.lift(|v| folder.fold_expr(v))),
Mac(mac_stmt) => {
Mac(mac_stmt.lift(|(mac, style, attrs)| {
- (folder.fold_mac(mac), style, attrs.lift(|a| folder.fold_attribute(a)))
- }))
+ (folder.fold_mac(mac),
+ style,
+ attrs.lift(|a| folder.fold_attribute(a)))
+ }))
}
}
@@ -927,11 +932,11 @@
List(path, items) => {
List(folder.fold_path(path),
items.lift(|PathListItem { name, rename }: PathListItem| {
- PathListItem {
- name: folder.fold_ident(name),
- rename: rename.map(|i| folder.fold_ident(i)),
- }
- }))
+ PathListItem {
+ name: folder.fold_ident(name),
+ rename: rename.map(|i| folder.fold_ident(i)),
+ }
+ }))
}
}
}
diff --git a/src/generics.rs b/src/generics.rs
index 46d7c43..276a7b0 100644
--- a/src/generics.rs
+++ b/src/generics.rs
@@ -337,7 +337,10 @@
tokens.append("<");
tokens.append_separated(&self.0.lifetimes, ",");
// Leave off the type parameter defaults
- for (i, ty_param) in self.0.ty_params.iter().enumerate() {
+ for (i, ty_param) in self.0
+ .ty_params
+ .iter()
+ .enumerate() {
if i > 0 || has_lifetimes {
tokens.append(",");
}
@@ -360,13 +363,19 @@
if has_lifetimes || has_ty_params {
tokens.append("<");
// Leave off the lifetime bounds and attributes
- let lifetimes = self.0.lifetimes.iter().map(|ld| &ld.lifetime);
+ let lifetimes = self.0
+ .lifetimes
+ .iter()
+ .map(|ld| &ld.lifetime);
tokens.append_separated(lifetimes, ",");
if has_lifetimes && has_ty_params {
tokens.append(",");
}
// Leave off the type parameter bounds, defaults, and attributes
- let ty_params = self.0.ty_params.iter().map(|tp| &tp.ident);
+ let ty_params = self.0
+ .ty_params
+ .iter()
+ .map(|tp| &tp.ident);
tokens.append_separated(ty_params, ",");
tokens.append(">");
}
diff --git a/src/ident.rs b/src/ident.rs
index 29fd7e8..5989aae 100644
--- a/src/ident.rs
+++ b/src/ident.rs
@@ -105,10 +105,10 @@
for (i, ch) in input.char_indices() {
if !UnicodeXID::is_xid_start(ch) && !UnicodeXID::is_xid_continue(ch) {
return if i == 0 {
- IResult::Error
- } else {
- IResult::Done(&input[i..], input[..i].into())
- };
+ IResult::Error
+ } else {
+ IResult::Done(&input[i..], input[..i].into())
+ };
}
}
diff --git a/src/lib.rs b/src/lib.rs
index 7ba96a4..180390c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -28,8 +28,8 @@
#[cfg(feature = "full")]
mod expr;
#[cfg(feature = "full")]
-pub use expr::{Arm, BindingMode, Block, CaptureBy, Expr, ExprKind, FieldPat, FieldValue,
- Local, MacStmtStyle, Pat, RangeLimits, Stmt};
+pub use expr::{Arm, BindingMode, Block, CaptureBy, Expr, ExprKind, FieldPat, FieldValue, Local,
+ MacStmtStyle, Pat, RangeLimits, Stmt};
mod generics;
pub use generics::{Generics, Lifetime, LifetimeDef, TraitBoundModifier, TyParam, TyParamBound,
@@ -138,7 +138,9 @@
}
pub fn parse_ty_param_bound(input: &str) -> Result<TyParamBound, String> {
- unwrap("type parameter bound", generics::parsing::ty_param_bound, input)
+ unwrap("type parameter bound",
+ generics::parsing::ty_param_bound,
+ input)
}
pub fn parse_outer_attr(input: &str) -> Result<Attribute, String> {
diff --git a/src/lit.rs b/src/lit.rs
index 419ff74..81be285 100644
--- a/src/lit.rs
+++ b/src/lit.rs
@@ -291,8 +291,8 @@
}
chars.next();
if chars.peek()
- .map(|&ch| ch == '.' || UnicodeXID::is_xid_start(ch))
- .unwrap_or(false) {
+ .map(|&ch| ch == '.' || UnicodeXID::is_xid_start(ch))
+ .unwrap_or(false) {
return IResult::Error;
}
len += 1;
@@ -413,8 +413,8 @@
Lit::Str(ref s, StrStyle::Cooked) => s.to_tokens(tokens),
Lit::Str(ref s, StrStyle::Raw(n)) => {
tokens.append(&format!("r{delim}\"{string}\"{delim}",
- delim = iter::repeat("#").take(n).collect::<String>(),
- string = s));
+ delim = iter::repeat("#").take(n).collect::<String>(),
+ string = s));
}
Lit::ByteStr(ref v, StrStyle::Cooked) => {
let mut escaped = "b\"".to_string();
@@ -430,8 +430,8 @@
}
Lit::ByteStr(ref vec, StrStyle::Raw(n)) => {
tokens.append(&format!("br{delim}\"{string}\"{delim}",
- delim = iter::repeat("#").take(n).collect::<String>(),
- string = str::from_utf8(vec).unwrap()));
+ delim = iter::repeat("#").take(n).collect::<String>(),
+ string = str::from_utf8(vec).unwrap()));
}
Lit::Byte(b) => {
match b {
diff --git a/src/ty.rs b/src/ty.rs
index 6a84a2b..4055b6a 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -635,9 +635,9 @@
if qself.position > 0 {
tokens.append("as");
for (i, segment) in path.segments
- .iter()
- .take(qself.position)
- .enumerate() {
+ .iter()
+ .take(qself.position)
+ .enumerate() {
if i > 0 || path.global {
tokens.append("::");
}
diff --git a/src/visit.rs b/src/visit.rs
index 6c32fce..8c8645d 100644
--- a/src/visit.rs
+++ b/src/visit.rs
@@ -286,9 +286,7 @@
visitor.visit_lifetime(lifetime);
walk_list!(visitor, visit_lifetime, 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);
}
@@ -420,9 +418,7 @@
visitor.visit_ty(ty);
walk_list!(visitor, visit_impl_item, impl_items);
}
- ItemKind::Mac(ref mac) => {
- visitor.visit_mac(mac)
- }
+ ItemKind::Mac(ref mac) => visitor.visit_mac(mac),
}
}
@@ -497,7 +493,7 @@
}
ExprKind::Match(ref expr, ref arms) => {
visitor.visit_expr(expr);
- for &Arm{ref attrs, ref pats, ref guard, ref body} in arms {
+ for &Arm { ref attrs, ref pats, ref guard, ref body } in arms {
walk_list!(visitor, visit_attribute, attrs);
walk_list!(visitor, visit_pat, pats);
if let Some(ref guard) = *guard {
@@ -563,7 +559,7 @@
}
ExprKind::Struct(ref path, ref fields, ref maybe_base) => {
visitor.visit_path(path);
- for &FieldValue{ref ident, ref expr, ..} in fields {
+ for &FieldValue { ref ident, ref expr, .. } in fields {
visitor.visit_ident(ident);
visitor.visit_expr(expr);
}
@@ -611,7 +607,7 @@
}
Pat::Struct(ref path, ref field_pats, _) => {
visitor.visit_path(path);
- for &FieldPat{ref ident, ref pat, ..} in field_pats {
+ for &FieldPat { ref ident, ref pat, .. } in field_pats {
visitor.visit_ident(ident);
visitor.visit_pat(pat);
}
@@ -657,7 +653,8 @@
pub fn walk_fn_decl<V: Visitor>(visitor: &mut V, fn_decl: &FnDecl) {
for input in &fn_decl.inputs {
match *input {
- FnArg::SelfRef(_, _) | FnArg::SelfValue(_) => {}
+ FnArg::SelfRef(_, _) |
+ FnArg::SelfValue(_) => {}
FnArg::Captured(ref pat, ref ty) => {
visitor.visit_pat(pat);
visitor.visit_ty(ty);
@@ -772,7 +769,7 @@
}
ViewPath::List(ref path, ref items) => {
visitor.visit_path(path);
- for &PathListItem{ref name, ref rename} in items {
+ for &PathListItem { ref name, ref rename } in items {
visitor.visit_ident(name);
walk_opt_ident(visitor, rename);
}