Rename PathParameter(s) to GenericArg(s)

5 files changed, 55 insertions, 59 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 9a05c5c063a..7bcaf9bbd52 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -12,7 +12,7 @@
 
 pub use self::TyParamBound::*;
 pub use self::UnsafeSource::*;
-pub use self::PathParameters::*;
+pub use self::GenericArgs::*;
 pub use symbol::{Ident, Symbol as Name};
 pub use util::ThinVec;
 pub use util::parser::ExprPrecedence;
@@ -135,7 +135,7 @@ pub struct PathSegment {
     /// `Some` means that parameter list is supplied (`Path<X, Y>`)
     /// but it can be empty (`Path<>`).
     /// `P` is used as a size optimization for the common case with no parameters.
-    pub parameters: Option<P<PathParameters>>,
+    pub parameters: Option<P<GenericArgs>>,
 }
 
 impl PathSegment {
@@ -151,14 +151,14 @@ impl PathSegment {
 ///
 /// E.g. `<A, B>` as in `Foo<A, B>` or `(A, B)` as in `Foo(A, B)`
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum PathParameters {
+pub enum GenericArgs {
     /// The `<'a, A,B,C>` in `foo::bar::baz::<'a, A,B,C>`
     AngleBracketed(AngleBracketedParameterData),
     /// The `(A,B)` and `C` in `Foo(A,B) -> C`
     Parenthesized(ParenthesizedParameterData),
 }
 
-impl PathParameters {
+impl GenericArgs {
     pub fn span(&self) -> Span {
         match *self {
             AngleBracketed(ref data) => data.span,
@@ -187,36 +187,36 @@ pub struct AngleBracketedParameterData {
 }
 
 impl AngleBracketedParameterData {
-    pub fn lifetimes(&self) -> Vec<&Lifetime> {
+    pub fn lifetimes(&self) -> impl DoubleEndedIterator<Item = &Lifetime> {
         self.parameters.iter().filter_map(|p| {
             if let AngleBracketedParam::Lifetime(lt) = p {
                 Some(lt)
             } else {
                 None
             }
-        }).collect()
+        })
     }
 
-    pub fn types(&self) -> Vec<&P<Ty>> {
+    pub fn types(&self) -> impl DoubleEndedIterator<Item = &P<Ty>> {
         self.parameters.iter().filter_map(|p| {
             if let AngleBracketedParam::Type(ty) = p {
                 Some(ty)
             } else {
                 None
             }
-        }).collect()
+        })
     }
 }
 
-impl Into<Option<P<PathParameters>>> for AngleBracketedParameterData {
-    fn into(self) -> Option<P<PathParameters>> {
-        Some(P(PathParameters::AngleBracketed(self)))
+impl Into<Option<P<GenericArgs>>> for AngleBracketedParameterData {
+    fn into(self) -> Option<P<GenericArgs>> {
+        Some(P(GenericArgs::AngleBracketed(self)))
     }
 }
 
-impl Into<Option<P<PathParameters>>> for ParenthesizedParameterData {
-    fn into(self) -> Option<P<PathParameters>> {
-        Some(P(PathParameters::Parenthesized(self)))
+impl Into<Option<P<GenericArgs>>> for ParenthesizedParameterData {
+    fn into(self) -> Option<P<GenericArgs>> {
+        Some(P(GenericArgs::Parenthesized(self)))
     }
 }
 
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index fc70ee9c38f..decb7e56132 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -133,7 +133,11 @@ pub trait Folder : Sized {
     }
 
     fn fold_param(&mut self, p: AngleBracketedParam) -> AngleBracketedParam {
-        noop_fold_param(p, self)
+        match p {
+            AngleBracketedParam::Lifetime(lt) =>
+                AngleBracketedParam::Lifetime(self.fold_lifetime(lt)),
+            AngleBracketedParam::Type(ty) => AngleBracketedParam::Type(self.fold_ty(ty)),
+        }
     }
 
     fn fold_ty(&mut self, t: P<Ty>) -> P<Ty> {
@@ -176,8 +180,8 @@ pub trait Folder : Sized {
         noop_fold_qpath(qs, p, self)
     }
 
-    fn fold_path_parameters(&mut self, p: PathParameters) -> PathParameters {
-        noop_fold_path_parameters(p, self)
+    fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs {
+        noop_fold_generic_args(p, self)
     }
 
     fn fold_angle_bracketed_parameter_data(&mut self, p: AngleBracketedParameterData)
@@ -357,19 +361,6 @@ pub fn noop_fold_ty_binding<T: Folder>(b: TypeBinding, fld: &mut T) -> TypeBindi
     }
 }
 
-pub fn noop_fold_param<T: Folder>(p: AngleBracketedParam,
-                                  fld: &mut T)
-                                  -> AngleBracketedParam {
-    match p {
-        AngleBracketedParam::Lifetime(lt) => {
-            AngleBracketedParam::Lifetime(noop_fold_lifetime(lt, fld))
-        }
-        AngleBracketedParam::Type(ty) => {
-            AngleBracketedParam::Type(noop_fold_ty(ty, fld))
-        }
-    }
-}
-
 pub fn noop_fold_ty<T: Folder>(t: P<Ty>, fld: &mut T) -> P<Ty> {
     t.map(|Ty {id, node, span}| Ty {
         id: fld.new_id(id),
@@ -452,7 +443,7 @@ pub fn noop_fold_path<T: Folder>(Path { segments, span }: Path, fld: &mut T) ->
     Path {
         segments: segments.move_map(|PathSegment {ident, parameters}| PathSegment {
             ident: fld.fold_ident(ident),
-            parameters: parameters.map(|ps| ps.map(|ps| fld.fold_path_parameters(ps))),
+            parameters: parameters.map(|ps| ps.map(|ps| fld.fold_generic_args(ps))),
         }),
         span: fld.new_span(span)
     }
@@ -471,14 +462,14 @@ pub fn noop_fold_qpath<T: Folder>(qself: Option<QSelf>,
     (qself, fld.fold_path(path))
 }
 
-pub fn noop_fold_path_parameters<T: Folder>(path_parameters: PathParameters, fld: &mut T)
-                                            -> PathParameters
+pub fn noop_fold_generic_args<T: Folder>(generic_args: GenericArgs, fld: &mut T)
+                                         -> GenericArgs
 {
-    match path_parameters {
-        PathParameters::AngleBracketed(data) =>
-            PathParameters::AngleBracketed(fld.fold_angle_bracketed_parameter_data(data)),
-        PathParameters::Parenthesized(data) =>
-            PathParameters::Parenthesized(fld.fold_parenthesized_parameter_data(data)),
+    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)),
     }
 }
 
@@ -1201,7 +1192,7 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span, attrs}: Expr, folder: &mu
                     PathSegment {
                         ident: folder.fold_ident(seg.ident),
                         parameters: seg.parameters.map(|ps| {
-                            ps.map(|ps| folder.fold_path_parameters(ps))
+                            ps.map(|ps| folder.fold_generic_args(ps))
                         }),
                     },
                     folder.fold_exprs(args))
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 282b5dd545a..287fe0b636f 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1992,7 +1992,7 @@ impl<'a> State<'a> {
         self.s.word(".")?;
         self.print_ident(segment.ident)?;
         if let Some(ref parameters) = segment.parameters {
-            self.print_path_parameters(parameters, true)?;
+            self.print_generic_args(parameters, true)?;
         }
         self.print_call_post(base_args)
     }
@@ -2436,7 +2436,7 @@ impl<'a> State<'a> {
            segment.ident.name != keywords::DollarCrate.name() {
             self.print_ident(segment.ident)?;
             if let Some(ref parameters) = segment.parameters {
-                self.print_path_parameters(parameters, colons_before_params)?;
+                self.print_generic_args(parameters, colons_before_params)?;
             }
         } else if segment.ident.name == keywords::DollarCrate.name() {
             self.print_dollar_crate(segment.ident.span.ctxt())?;
@@ -2463,13 +2463,13 @@ impl<'a> State<'a> {
         let item_segment = path.segments.last().unwrap();
         self.print_ident(item_segment.ident)?;
         match item_segment.parameters {
-            Some(ref parameters) => self.print_path_parameters(parameters, colons_before_params),
+            Some(ref parameters) => self.print_generic_args(parameters, colons_before_params),
             None => Ok(()),
         }
     }
 
-    fn print_path_parameters(&mut self,
-                             parameters: &ast::PathParameters,
+    fn print_generic_args(&mut self,
+                             parameters: &ast::GenericArgs,
                              colons_before_params: bool)
                              -> io::Result<()>
     {
@@ -2478,7 +2478,7 @@ impl<'a> State<'a> {
         }
 
         match *parameters {
-            ast::PathParameters::AngleBracketed(ref data) => {
+            ast::GenericArgs::AngleBracketed(ref data) => {
                 self.s.word("<")?;
 
                 self.commasep(Inconsistent, &data.parameters, |s, p| s.print_param(p))?;
@@ -2499,7 +2499,7 @@ impl<'a> State<'a> {
                 self.s.word(">")?
             }
 
-            ast::PathParameters::Parenthesized(ref data) => {
+            ast::GenericArgs::Parenthesized(ref data) => {
                 self.s.word("(")?;
                 self.commasep(
                     Inconsistent,
diff --git a/src/libsyntax/util/node_count.rs b/src/libsyntax/util/node_count.rs
index d4c6b4b158b..95ae9f9bcf8 100644
--- a/src/libsyntax/util/node_count.rs
+++ b/src/libsyntax/util/node_count.rs
@@ -137,9 +137,9 @@ impl<'ast> Visitor<'ast> for NodeCounter {
         self.count += 1;
         walk_use_tree(self, use_tree, id)
     }
-    fn visit_path_parameters(&mut self, path_span: Span, path_parameters: &PathParameters) {
+    fn visit_generic_args(&mut self, path_span: Span, generic_args: &GenericArgs) {
         self.count += 1;
-        walk_path_parameters(self, path_span, path_parameters)
+        walk_generic_args(self, path_span, generic_args)
     }
     fn visit_assoc_type_binding(&mut self, type_binding: &TypeBinding) {
         self.count += 1;
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index a4b9e3d7d45..6dc61f3058a 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -128,8 +128,14 @@ pub trait Visitor<'ast>: Sized {
     fn visit_path_segment(&mut self, path_span: Span, path_segment: &'ast PathSegment) {
         walk_path_segment(self, path_span, path_segment)
     }
-    fn visit_path_parameters(&mut self, path_span: Span, path_parameters: &'ast PathParameters) {
-        walk_path_parameters(self, path_span, path_parameters)
+    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 AngleBracketedParam) {
+        match param {
+            AngleBracketedParam::Lifetime(lt) => self.visit_lifetime(lt),
+            AngleBracketedParam::Type(ty)     => self.visit_ty(ty),
+        }
     }
     fn visit_assoc_type_binding(&mut self, type_binding: &'ast TypeBinding) {
         walk_assoc_type_binding(self, type_binding)
@@ -376,22 +382,21 @@ pub fn walk_path_segment<'a, V: Visitor<'a>>(visitor: &mut V,
                                              segment: &'a PathSegment) {
     visitor.visit_ident(segment.ident);
     if let Some(ref parameters) = segment.parameters {
-        visitor.visit_path_parameters(path_span, parameters);
+        visitor.visit_generic_args(path_span, parameters);
     }
 }
 
-pub fn walk_path_parameters<'a, V>(visitor: &mut V,
-                                   _path_span: Span,
-                                   path_parameters: &'a PathParameters)
+pub fn walk_generic_args<'a, V>(visitor: &mut V,
+                                _path_span: Span,
+                                generic_args: &'a GenericArgs)
     where V: Visitor<'a>,
 {
-    match *path_parameters {
-        PathParameters::AngleBracketed(ref data) => {
-            walk_list!(visitor, visit_lifetime, data.lifetimes());
-            walk_list!(visitor, visit_ty, data.types());
+    match *generic_args {
+        GenericArgs::AngleBracketed(ref data) => {
+            walk_list!(visitor, visit_angle_bracketed_param, &data.parameters);
             walk_list!(visitor, visit_assoc_type_binding, &data.bindings);
         }
-        PathParameters::Parenthesized(ref data) => {
+        GenericArgs::Parenthesized(ref data) => {
             walk_list!(visitor, visit_ty, &data.inputs);
             walk_list!(visitor, visit_ty, &data.output);
         }