Make method and variable names more consistent

5 files changed, 45 insertions, 39 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 7ff00123624..5ae520050e5 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -188,8 +188,8 @@ pub struct AngleBracketedArgs {
 
 impl AngleBracketedArgs {
     pub fn lifetimes(&self) -> impl DoubleEndedIterator<Item = &Lifetime> {
-        self.args.iter().filter_map(|p| {
-            if let GenericArg::Lifetime(lt) = p {
+        self.args.iter().filter_map(|arg| {
+            if let GenericArg::Lifetime(lt) = arg {
                 Some(lt)
             } else {
                 None
@@ -198,8 +198,8 @@ impl AngleBracketedArgs {
     }
 
     pub fn types(&self) -> impl DoubleEndedIterator<Item = &P<Ty>> {
-        self.args.iter().filter_map(|p| {
-            if let GenericArg::Type(ty) = p {
+        self.args.iter().filter_map(|arg| {
+            if let GenericArg::Type(ty) = arg {
                 Some(ty)
             } else {
                 None
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 05a345fb2a1..c544adb5c1c 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -31,7 +31,7 @@ pub trait AstBuilder {
     fn path_all(&self, sp: Span,
                 global: bool,
                 idents: Vec<ast::Ident>,
-                parameters: Vec<ast::GenericArg>,
+                args: Vec<ast::GenericArg>,
                 bindings: Vec<ast::TypeBinding>)
         -> ast::Path;
 
@@ -42,7 +42,7 @@ pub trait AstBuilder {
     fn qpath_all(&self, self_type: P<ast::Ty>,
                 trait_path: ast::Path,
                 ident: ast::Ident,
-                parameters: Vec<ast::GenericArg>,
+                args: Vec<ast::GenericArg>,
                 bindings: Vec<ast::TypeBinding>)
                 -> (ast::QSelf, ast::Path);
 
@@ -302,13 +302,13 @@ pub trait AstBuilder {
 
 impl<'a> AstBuilder for ExtCtxt<'a> {
     fn path(&self, span: Span, strs: Vec<ast::Ident> ) -> ast::Path {
-        self.path_all(span, false, strs, Vec::new(), Vec::new())
+        self.path_all(span, false, strs, vec![], vec![])
     }
     fn path_ident(&self, span: Span, id: ast::Ident) -> ast::Path {
         self.path(span, vec![id])
     }
     fn path_global(&self, span: Span, strs: Vec<ast::Ident> ) -> ast::Path {
-        self.path_all(span, true, strs, Vec::new(), Vec::new())
+        self.path_all(span, true, strs, vec![], vec![])
     }
     fn path_all(&self,
                 span: Span,
@@ -318,7 +318,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
                 bindings: Vec<ast::TypeBinding> )
                 -> ast::Path {
         let last_ident = idents.pop().unwrap();
-        let mut segments: Vec<ast::PathSegment> = Vec::new();
+        let mut segments: Vec<ast::PathSegment> = vec![];
 
         segments.extend(idents.into_iter().map(|ident| {
             ast::PathSegment::from_ident(ident.with_span_pos(span))
@@ -424,7 +424,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
             self.path_all(DUMMY_SP,
                           true,
                           self.std_path(&["option", "Option"]),
-                          vec![ ast::GenericArg::Type(ty) ],
+                          vec![ast::GenericArg::Type(ty)],
                           Vec::new()))
     }
 
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index dc23ed19d1b..f74fe1feb40 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -132,10 +132,9 @@ pub trait Folder : Sized {
         noop_fold_exprs(es, self)
     }
 
-    fn fold_param(&mut self, p: GenericArg) -> GenericArg {
-        match p {
-            GenericArg::Lifetime(lt) =>
-                GenericArg::Lifetime(self.fold_lifetime(lt)),
+    fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg {
+        match arg {
+            GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.fold_lifetime(lt)),
             GenericArg::Type(ty) => GenericArg::Type(self.fold_ty(ty)),
         }
     }
@@ -441,9 +440,9 @@ pub fn noop_fold_usize<T: Folder>(i: usize, _: &mut T) -> usize {
 
 pub fn noop_fold_path<T: Folder>(Path { segments, span }: Path, fld: &mut T) -> Path {
     Path {
-        segments: segments.move_map(|PathSegment {ident, args}| PathSegment {
+        segments: segments.move_map(|PathSegment { ident, args }| PathSegment {
             ident: fld.fold_ident(ident),
-            args: args.map(|ps| ps.map(|ps| fld.fold_generic_args(ps))),
+            args: args.map(|args| args.map(|args| fld.fold_generic_args(args))),
         }),
         span: fld.new_span(span)
     }
@@ -462,14 +461,15 @@ pub fn noop_fold_qpath<T: Folder>(qself: Option<QSelf>,
     (qself, fld.fold_path(path))
 }
 
-pub fn noop_fold_generic_args<T: Folder>(generic_args: GenericArgs, fld: &mut T)
-                                         -> GenericArgs
+pub fn noop_fold_generic_args<T: Folder>(generic_args: GenericArgs, fld: &mut T) -> GenericArgs
 {
     match generic_args {
-        GenericArgs::AngleBracketed(data) =>
-            GenericArgs::AngleBracketed(fld.fold_angle_bracketed_parameter_data(data)),
-        GenericArgs::Parenthesized(data) =>
-            GenericArgs::Parenthesized(fld.fold_parenthesized_parameter_data(data)),
+        GenericArgs::AngleBracketed(data) => {
+            GenericArgs::AngleBracketed(fld.fold_angle_bracketed_parameter_data(data))
+        }
+        GenericArgs::Parenthesized(data) => {
+            GenericArgs::Parenthesized(fld.fold_parenthesized_parameter_data(data))
+        }
     }
 }
 
@@ -478,9 +478,11 @@ pub fn noop_fold_angle_bracketed_parameter_data<T: Folder>(data: AngleBracketedA
                                                            -> AngleBracketedArgs
 {
     let AngleBracketedArgs { args, bindings, span } = data;
-    AngleBracketedArgs { args: args.move_map(|p| fld.fold_param(p)),
-                                  bindings: bindings.move_map(|b| fld.fold_ty_binding(b)),
-                                  span: fld.new_span(span) }
+    AngleBracketedArgs {
+        args: args.move_map(|arg| fld.fold_generic_arg(arg)),
+        bindings: bindings.move_map(|b| fld.fold_ty_binding(b)),
+        span: fld.new_span(span)
+    }
 }
 
 pub fn noop_fold_parenthesized_parameter_data<T: Folder>(data: ParenthesizedArgData,
@@ -488,9 +490,11 @@ pub fn noop_fold_parenthesized_parameter_data<T: Folder>(data: ParenthesizedArgD
                                                          -> ParenthesizedArgData
 {
     let ParenthesizedArgData { inputs, output, span } = data;
-    ParenthesizedArgData { inputs: inputs.move_map(|ty| fld.fold_ty(ty)),
-                                 output: output.map(|ty| fld.fold_ty(ty)),
-                                 span: fld.new_span(span) }
+    ParenthesizedArgData {
+        inputs: inputs.move_map(|ty| fld.fold_ty(ty)),
+        output: output.map(|ty| fld.fold_ty(ty)),
+        span: fld.new_span(span)
+    }
 }
 
 pub fn noop_fold_local<T: Folder>(l: P<Local>, fld: &mut T) -> P<Local> {
@@ -1191,8 +1195,8 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span, attrs}: Expr, folder: &mu
                 ExprKind::MethodCall(
                     PathSegment {
                         ident: folder.fold_ident(seg.ident),
-                        args: seg.args.map(|ps| {
-                            ps.map(|ps| folder.fold_generic_args(ps))
+                        args: seg.args.map(|args| {
+                            args.map(|args| folder.fold_generic_args(args))
                         }),
                     },
                     folder.fold_exprs(args))
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 3b487430c52..3e0e533bc08 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1017,8 +1017,8 @@ impl<'a> State<'a> {
         Ok(())
     }
 
-    pub fn print_param(&mut self, param: &GenericArg) -> io::Result<()> {
-        match param {
+    pub fn print_generic_arg(&mut self, generic_arg: &GenericArg) -> io::Result<()> {
+        match generic_arg {
             GenericArg::Lifetime(lt) => self.print_lifetime(lt),
             GenericArg::Type(ty) => self.print_type(ty),
         }
@@ -2469,9 +2469,9 @@ impl<'a> State<'a> {
     }
 
     fn print_generic_args(&mut self,
-                             args: &ast::GenericArgs,
-                             colons_before_params: bool)
-                             -> io::Result<()>
+                          args: &ast::GenericArgs,
+                          colons_before_params: bool)
+                          -> io::Result<()>
     {
         if colons_before_params {
             self.s.word("::")?
@@ -2481,7 +2481,9 @@ impl<'a> State<'a> {
             ast::GenericArgs::AngleBracketed(ref data) => {
                 self.s.word("<")?;
 
-                self.commasep(Inconsistent, &data.args, |s, p| s.print_param(p))?;
+                self.commasep(Inconsistent, &data.args, |s, generic_arg| {
+                    s.print_generic_arg(generic_arg)
+                })?;
 
                 let mut comma = data.args.len() != 0;
 
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 906f1941cd6..5ac33701baf 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -131,8 +131,8 @@ pub trait Visitor<'ast>: Sized {
     fn visit_generic_args(&mut self, path_span: Span, generic_args: &'ast GenericArgs) {
         walk_generic_args(self, path_span, generic_args)
     }
-    fn visit_angle_bracketed_param(&mut self, param: &'ast GenericArg) {
-        match param {
+    fn visit_generic_arg(&mut self, generic_arg: &'ast GenericArg) {
+        match generic_arg {
             GenericArg::Lifetime(lt) => self.visit_lifetime(lt),
             GenericArg::Type(ty)     => self.visit_ty(ty),
         }
@@ -393,7 +393,7 @@ pub fn walk_generic_args<'a, V>(visitor: &mut V,
 {
     match *generic_args {
         GenericArgs::AngleBracketed(ref data) => {
-            walk_list!(visitor, visit_angle_bracketed_param, &data.args);
+            walk_list!(visitor, visit_generic_arg, &data.args);
             walk_list!(visitor, visit_assoc_type_binding, &data.bindings);
         }
         GenericArgs::Parenthesized(ref data) => {