Rename PathParameter(s) to GenericArg(s)

Author: varkor

src/librustc/hir/intravisit.rs

@@ -344,10 +344,10 @@ pub trait Visitor<'v> : Sized {
     fn visit_label(&mut self, label: &'v Label) {
         walk_label(self, label)
     }
-    fn visit_path_param(&mut self, path_param: &'v PathParam) {
-        match path_param {
-            PathParam::Lifetime(lt) => self.visit_lifetime(lt),
-            PathParam::Type(ty) => self.visit_ty(ty),
+    fn visit_generic_arg(&mut self, generic_arg: &'v GenericArg) {
+        match generic_arg {
+            GenericArg::Lifetime(lt) => self.visit_lifetime(lt),
+            GenericArg::Type(ty) => self.visit_ty(ty),
         }
     }
     fn visit_lifetime(&mut self, lifetime: &'v Lifetime) {
@@ -362,8 +362,8 @@ pub trait Visitor<'v> : Sized {
     fn visit_path_segment(&mut self, path_span: Span, path_segment: &'v PathSegment) {
         walk_path_segment(self, path_span, path_segment)
     }
-    fn visit_path_parameters(&mut self, path_span: Span, path_parameters: &'v PathParameters) {
-        walk_path_parameters(self, path_span, path_parameters)
+    fn visit_generic_args(&mut self, path_span: Span, generic_args: &'v GenericArgs) {
+        walk_generic_args(self, path_span, generic_args)
     }
     fn visit_assoc_type_binding(&mut self, type_binding: &'v TypeBinding) {
         walk_assoc_type_binding(self, type_binding)
@@ -649,15 +649,15 @@ pub fn walk_path_segment<'v, V: Visitor<'v>>(visitor: &mut V,
                                              segment: &'v PathSegment) {
     visitor.visit_name(path_span, segment.name);
     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<'v, V: Visitor<'v>>(visitor: &mut V,
+pub fn walk_generic_args<'v, V: Visitor<'v>>(visitor: &mut V,
                                                 _path_span: Span,
-                                                path_parameters: &'v PathParameters) {
-    walk_list!(visitor, visit_path_param, &path_parameters.parameters);
-    walk_list!(visitor, visit_assoc_type_binding, &path_parameters.bindings);
+                                                generic_args: &'v GenericArgs) {
+    walk_list!(visitor, visit_generic_arg, &generic_args.parameters);
+    walk_list!(visitor, visit_assoc_type_binding, &generic_args.bindings);
 }
 
 pub fn walk_assoc_type_binding<'v, V: Visitor<'v>>(visitor: &mut V,

src/librustc/hir/lowering.rs

@@ -46,7 +46,7 @@ use hir::HirVec;
 use hir::map::{DefKey, DefPathData, Definitions};
 use hir::def_id::{DefId, DefIndex, DefIndexAddressSpace, CRATE_DEF_INDEX};
 use hir::def::{Def, PathResolution, PerNS};
-use hir::PathParam;
+use hir::GenericArg;
 use lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES};
 use middle::cstore::CrateStore;
 use rustc_data_structures::indexed_vec::IndexVec;
@@ -1038,16 +1038,16 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_path_param(&mut self,
+    fn lower_generic_arg(&mut self,
                         p: &AngleBracketedParam,
                         itctx: ImplTraitContext)
-                        -> PathParam {
+                        -> GenericArg {
         match p {
             AngleBracketedParam::Lifetime(lt) => {
-                PathParam::Lifetime(self.lower_lifetime(&lt))
+                GenericArg::Lifetime(self.lower_lifetime(&lt))
             }
             AngleBracketedParam::Type(ty) => {
-                PathParam::Type(self.lower_ty(&ty, itctx))
+                GenericArg::Type(self.lower_ty(&ty, itctx))
             }
         }
     }
@@ -1322,15 +1322,15 @@ impl<'a> LoweringContext<'a> {
                 hir::intravisit::NestedVisitorMap::None
             }
 
-            fn visit_path_parameters(&mut self, span: Span, parameters: &'v hir::PathParameters) {
+            fn visit_generic_args(&mut self, span: Span, parameters: &'v hir::GenericArgs) {
                 // Don't collect elided lifetimes used inside of `Fn()` syntax.
                 if parameters.parenthesized {
                     let old_collect_elided_lifetimes = self.collect_elided_lifetimes;
                     self.collect_elided_lifetimes = false;
-                    hir::intravisit::walk_path_parameters(self, span, parameters);
+                    hir::intravisit::walk_generic_args(self, span, parameters);
                     self.collect_elided_lifetimes = old_collect_elided_lifetimes;
                 } else {
-                    hir::intravisit::walk_path_parameters(self, span, parameters);
+                    hir::intravisit::walk_generic_args(self, span, parameters);
                 }
             }
 
@@ -1567,7 +1567,7 @@ impl<'a> LoweringContext<'a> {
                         assert!(!def_id.is_local());
                         let item_generics =
                             self.cstore.item_generics_cloned_untracked(def_id, self.sess);
-                        let n = item_generics.own_counts().lifetimes();
+                        let n = item_generics.own_counts().lifetimes;
                         self.type_def_lifetime_params.insert(def_id, n);
                         n
                     });
@@ -1684,13 +1684,14 @@ impl<'a> LoweringContext<'a> {
         parenthesized_generic_args: ParenthesizedGenericArgs,
         itctx: ImplTraitContext,
     ) -> hir::PathSegment {
-        let (mut parameters, infer_types) = if let Some(ref parameters) = segment.parameters {
+        let (mut generic_args, infer_types) =
+            if let Some(ref generic_args) = segment.parameters {
             let msg = "parenthesized parameters may only be used with a trait";
-            match **path_params {
-                PathParameters::AngleBracketed(ref data) => {
+            match **generic_args {
+                GenericArgs::AngleBracketed(ref data) => {
                     self.lower_angle_bracketed_parameter_data(data, param_mode, itctx)
                 }
-                PathParameters::Parenthesized(ref data) => match parenthesized_generic_args {
+                GenericArgs::Parenthesized(ref data) => match parenthesized_generic_args {
                     ParenthesizedGenericArgs::Ok => self.lower_parenthesized_parameter_data(data),
                     ParenthesizedGenericArgs::Warn => {
                         self.sess.buffer_lint(
@@ -1699,30 +1700,30 @@ impl<'a> LoweringContext<'a> {
                             data.span,
                             msg.into(),
                         );
-                        (hir::PathParameters::none(), true)
+                        (hir::GenericArgs::none(), true)
                     }
                     ParenthesizedGenericArgs::Err => {
                         struct_span_err!(self.sess, data.span, E0214, "{}", msg)
                             .span_label(data.span, "only traits may use parentheses")
                             .emit();
-                        (hir::PathParameters::none(), true)
+                        (hir::GenericArgs::none(), true)
                     }
                 },
             }
         } else {
             self.lower_angle_bracketed_parameter_data(&Default::default(), param_mode, itctx)
         };
 
-        if !parameters.parenthesized && parameters.lifetimes.is_empty() {
-            path_params.parameters = (0..expected_lifetimes).map(|_| {
-                PathParam::Lifetime(self.elided_lifetime(path_span))
-            }).chain(path_params.parameters.into_iter()).collect();
+        if !generic_args.parenthesized && generic_args.lifetimes().count() == 0 {
+            generic_args.parameters = (0..expected_lifetimes).map(|_| {
+                GenericArg::Lifetime(self.elided_lifetime(path_span))
+            }).chain(generic_args.parameters.into_iter()).collect();
         }
 
         hir::PathSegment::new(
-            self.lower_ident(segment.ident),
-            path_params,
-            infer_types,
+            self.lower_ident(segment.identifier),
+            generic_args,
+            infer_types
         )
     }
 
@@ -1731,14 +1732,14 @@ impl<'a> LoweringContext<'a> {
         data: &AngleBracketedParameterData,
         param_mode: ParamMode,
         itctx: ImplTraitContext,
-    ) -> (hir::PathParameters, bool) {
+    ) -> (hir::GenericArgs, bool) {
         let &AngleBracketedParameterData { ref parameters, ref bindings, .. } = data;
-        (hir::PathParameters {
-            parameters: parameters.iter().map(|p| self.lower_path_param(p, itctx)).collect(),
+        (hir::GenericArgs {
+            parameters: parameters.iter().map(|p| self.lower_generic_arg(p, itctx)).collect(),
             bindings: bindings.iter().map(|b| self.lower_ty_binding(b, itctx)).collect(),
             parenthesized: false,
         },
-        types.is_empty() && param_mode == ParamMode::Optional)
+        data.types().count() == 0 && param_mode == ParamMode::Optional)
     }
 
     fn lower_parenthesized_parameter_data(
@@ -1774,8 +1775,8 @@ impl<'a> LoweringContext<'a> {
                 };
 
                 (
-                    hir::PathParameters {
-                        parameters: hir_vec![PathParam::Type(mk_tup(this, inputs, span))],
+                    hir::GenericArgs {
+                        parameters: hir_vec![GenericArg::Type(mk_tup(this, inputs, span))],
                         bindings: hir_vec![
                             hir::TypeBinding {
                                 id: this.next_id().node_id,

src/librustc/hir/mod.rs

@@ -327,7 +327,7 @@ pub struct PathSegment {
     /// this is more than just simple syntactic sugar; the use of
     /// parens affects the region binding rules, so we preserve the
     /// distinction.
-    pub parameters: Option<P<PathParameters>>,
+    pub parameters: Option<P<GenericArgs>>,
 
     /// Whether to infer remaining type parameters, if any.
     /// This only applies to expression and pattern paths, and
@@ -346,7 +346,7 @@ impl PathSegment {
         }
     }
 
-    pub fn new(name: Name, parameters: PathParameters, infer_types: bool) -> Self {
+    pub fn new(name: Name, parameters: GenericArgs, infer_types: bool) -> Self {
         PathSegment {
             name,
             infer_types,
@@ -359,11 +359,11 @@ impl PathSegment {
     }
 
     // FIXME: hack required because you can't create a static
-    // PathParameters, so you can't just return a &PathParameters.
+    // GenericArgs, so you can't just return a &GenericArgs.
     pub fn with_parameters<F, R>(&self, f: F) -> R
-        where F: FnOnce(&PathParameters) -> R
+        where F: FnOnce(&GenericArgs) -> R
     {
-        let dummy = PathParameters::none();
+        let dummy = GenericArgs::none();
         f(if let Some(ref params) = self.parameters {
             &params
         } else {
@@ -373,15 +373,15 @@ impl PathSegment {
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum PathParam {
+pub enum GenericArg {
     Lifetime(Lifetime),
     Type(P<Ty>),
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub struct PathParameters {
+pub struct GenericArgs {
     /// The generic parameters for this path segment.
-    pub parameters: HirVec<PathParam>,
+    pub parameters: HirVec<GenericArg>,
     /// Bindings (equality constraints) on associated types, if present.
     /// E.g., `Foo<A=Bar>`.
     pub bindings: HirVec<TypeBinding>,
@@ -391,7 +391,7 @@ pub struct PathParameters {
     pub parenthesized: bool,
 }
 
-impl PathParameters {
+impl GenericArgs {
     pub fn none() -> Self {
         Self {
             parameters: HirVec::new(),
@@ -406,33 +406,33 @@ impl PathParameters {
 
     pub fn inputs(&self) -> &[P<Ty>] {
         if self.parenthesized {
-            if let Some(ref ty) = self.types().get(0) {
+            if let Some(ref ty) = self.types().next() {
                 if let TyTup(ref tys) = ty.node {
                     return tys;
                 }
             }
         }
-        bug!("PathParameters::inputs: not a `Fn(T) -> U`");
+        bug!("GenericArgs::inputs: not a `Fn(T) -> U`");
     }
 
-    pub fn lifetimes(&self) -> Vec<&Lifetime> {
+    pub fn lifetimes(&self) -> impl DoubleEndedIterator<Item = &Lifetime> {
         self.parameters.iter().filter_map(|p| {
-            if let PathParam::Lifetime(lt) = p {
+            if let GenericArg::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 PathParam::Type(ty) = p {
+            if let GenericArg::Type(ty) = p {
                 Some(ty)
             } else {
                 None
             }
-        }).collect()
+        })
     }
 }
 
@@ -562,11 +562,11 @@ impl Generics {
         self.params.iter().any(|param| param.is_type_param())
     }
 
-    pub fn lifetimes<'a>(&'a self) -> impl Iterator<Item = &'a LifetimeDef> {
+    pub fn lifetimes<'a>(&'a self) -> impl DoubleEndedIterator<Item = &'a LifetimeDef> {
         self.params.lifetimes()
     }
 
-    pub fn ty_params<'a>(&'a self) -> impl Iterator<Item = &'a TyParam> {
+    pub fn ty_params<'a>(&'a self) -> impl DoubleEndedIterator<Item = &'a TyParam> {
         self.params.ty_params()
     }
 }