Merge pull request #261 from mystor/generic_arg_refactor

Generic arg refactor

src/gen/fold.rs

@@ -62,7 +62,7 @@ fn fold_abi(&mut self, i: Abi) -> Abi { fold_abi(self, i) }
 
 fn fold_abi_kind(&mut self, i: AbiKind) -> AbiKind { fold_abi_kind(self, i) }
 
-fn fold_angle_bracketed_parameter_data(&mut self, i: AngleBracketedParameterData) -> AngleBracketedParameterData { fold_angle_bracketed_parameter_data(self, i) }
+fn fold_angle_bracketed_generic_arguments(&mut self, i: AngleBracketedGenericArguments) -> AngleBracketedGenericArguments { fold_angle_bracketed_generic_arguments(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_arg_captured(&mut self, i: ArgCaptured) -> ArgCaptured { fold_arg_captured(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -97,6 +97,8 @@ fn fold_body_struct(&mut self, i: BodyStruct) -> BodyStruct { fold_body_struct(s
 fn fold_bound_lifetimes(&mut self, i: BoundLifetimes) -> BoundLifetimes { fold_bound_lifetimes(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_capture_by(&mut self, i: CaptureBy) -> CaptureBy { fold_capture_by(self, i) }
+
+fn fold_const_param(&mut self, i: ConstParam) -> ConstParam { fold_const_param(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_constness(&mut self, i: Constness) -> Constness { fold_constness(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -204,6 +206,8 @@ fn fold_foreign_item_static(&mut self, i: ForeignItemStatic) -> ForeignItemStati
 # [ cfg ( feature = "full" ) ]
 fn fold_foreign_item_type(&mut self, i: ForeignItemType) -> ForeignItemType { fold_foreign_item_type(self, i) }
 
+fn fold_generic_argument(&mut self, i: GenericArgument) -> GenericArgument { fold_generic_argument(self, i) }
+
 fn fold_generic_param(&mut self, i: GenericParam) -> GenericParam { fold_generic_param(self, i) }
 
 fn fold_generics(&mut self, i: Generics) -> Generics { fold_generics(self, i) }
@@ -276,7 +280,7 @@ fn fold_mutability(&mut self, i: Mutability) -> Mutability { fold_mutability(sel
 
 fn fold_nested_meta_item(&mut self, i: NestedMetaItem) -> NestedMetaItem { fold_nested_meta_item(self, i) }
 
-fn fold_parenthesized_parameter_data(&mut self, i: ParenthesizedParameterData) -> ParenthesizedParameterData { fold_parenthesized_parameter_data(self, i) }
+fn fold_parenthesized_generic_arguments(&mut self, i: ParenthesizedGenericArguments) -> ParenthesizedGenericArguments { fold_parenthesized_generic_arguments(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_pat(&mut self, i: Pat) -> Pat { fold_pat(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -303,15 +307,15 @@ fn fold_pat_tuple_struct(&mut self, i: PatTupleStruct) -> PatTupleStruct { fold_
 fn fold_pat_wild(&mut self, i: PatWild) -> PatWild { fold_pat_wild(self, i) }
 
 fn fold_path(&mut self, i: Path) -> Path { fold_path(self, i) }
+
+fn fold_path_arguments(&mut self, i: PathArguments) -> PathArguments { fold_path_arguments(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_path_glob(&mut self, i: PathGlob) -> PathGlob { fold_path_glob(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_path_list(&mut self, i: PathList) -> PathList { fold_path_list(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_path_list_item(&mut self, i: PathListItem) -> PathListItem { fold_path_list_item(self, i) }
 
-fn fold_path_parameters(&mut self, i: PathParameters) -> PathParameters { fold_path_parameters(self, i) }
-
 fn fold_path_segment(&mut self, i: PathSegment) -> PathSegment { fold_path_segment(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_path_simple(&mut self, i: PathSimple) -> PathSimple { fold_path_simple(self, i) }
@@ -424,13 +428,11 @@ pub fn fold_abi_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: AbiKind) -> AbiKi
     }
 }
 
-pub fn fold_angle_bracketed_parameter_data<V: Folder + ?Sized>(_visitor: &mut V, _i: AngleBracketedParameterData) -> AngleBracketedParameterData {
-    AngleBracketedParameterData {
+pub fn fold_angle_bracketed_generic_arguments<V: Folder + ?Sized>(_visitor: &mut V, _i: AngleBracketedGenericArguments) -> AngleBracketedGenericArguments {
+    AngleBracketedGenericArguments {
         turbofish: _i . turbofish,
         lt_token: _i . lt_token,
-        lifetimes: _i . lifetimes,
-        types: FoldHelper::lift(_i . types, |it| { _visitor.fold_type(it) }),
-        bindings: FoldHelper::lift(_i . bindings, |it| { _visitor.fold_type_binding(it) }),
+        args: FoldHelper::lift(_i . args, |it| { _visitor.fold_generic_argument(it) }),
         gt_token: _i . gt_token,
     }
 }
@@ -752,6 +754,18 @@ pub fn fold_capture_by<V: Folder + ?Sized>(_visitor: &mut V, _i: CaptureBy) -> C
         Ref => { Ref }
     }
 }
+
+pub fn fold_const_param<V: Folder + ?Sized>(_visitor: &mut V, _i: ConstParam) -> ConstParam {
+    ConstParam {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        const_token: _i . const_token,
+        ident: _i . ident,
+        colon_token: _i . colon_token,
+        ty: _visitor.fold_type(_i . ty),
+        eq_token: _i . eq_token,
+        default: (_i . default).map(|it| { _visitor.fold_expr(it) }),
+    }
+}
 # [ cfg ( feature = "full" ) ]
 pub fn fold_constness<V: Folder + ?Sized>(_visitor: &mut V, _i: Constness) -> Constness {
     use ::Constness::*;
@@ -1452,6 +1466,32 @@ pub fn fold_foreign_item_type<V: Folder + ?Sized>(_visitor: &mut V, _i: ForeignI
     }
 }
 
+pub fn fold_generic_argument<V: Folder + ?Sized>(_visitor: &mut V, _i: GenericArgument) -> GenericArgument {
+    use ::GenericArgument::*;
+    match _i {
+        Lifetime(_binding_0, ) => {
+            Lifetime (
+                _binding_0,
+            )
+        }
+        Type(_binding_0, ) => {
+            Type (
+                _visitor.fold_type(_binding_0),
+            )
+        }
+        TypeBinding(_binding_0, ) => {
+            TypeBinding (
+                _visitor.fold_type_binding(_binding_0),
+            )
+        }
+        Const(_binding_0, ) => {
+            Const (
+                full!(_visitor.fold_expr_block(_binding_0)),
+            )
+        }
+    }
+}
+
 pub fn fold_generic_param<V: Folder + ?Sized>(_visitor: &mut V, _i: GenericParam) -> GenericParam {
     use ::GenericParam::*;
     match _i {
@@ -1465,6 +1505,11 @@ pub fn fold_generic_param<V: Folder + ?Sized>(_visitor: &mut V, _i: GenericParam
                 _visitor.fold_type_param(_binding_0),
             )
         }
+        Const(_binding_0, ) => {
+            Const (
+                _visitor.fold_const_param(_binding_0),
+            )
+        }
     }
 }
 
@@ -1964,8 +2009,8 @@ pub fn fold_nested_meta_item<V: Folder + ?Sized>(_visitor: &mut V, _i: NestedMet
     }
 }
 
-pub fn fold_parenthesized_parameter_data<V: Folder + ?Sized>(_visitor: &mut V, _i: ParenthesizedParameterData) -> ParenthesizedParameterData {
-    ParenthesizedParameterData {
+pub fn fold_parenthesized_generic_arguments<V: Folder + ?Sized>(_visitor: &mut V, _i: ParenthesizedGenericArguments) -> ParenthesizedGenericArguments {
+    ParenthesizedGenericArguments {
         paren_token: _i . paren_token,
         inputs: FoldHelper::lift(_i . inputs, |it| { _visitor.fold_type(it) }),
         output: _visitor.fold_return_type(_i . output),
@@ -2132,6 +2177,23 @@ pub fn fold_path<V: Folder + ?Sized>(_visitor: &mut V, _i: Path) -> Path {
         segments: FoldHelper::lift(_i . segments, |it| { _visitor.fold_path_segment(it) }),
     }
 }
+
+pub fn fold_path_arguments<V: Folder + ?Sized>(_visitor: &mut V, _i: PathArguments) -> PathArguments {
+    use ::PathArguments::*;
+    match _i {
+        None => { None }
+        AngleBracketed(_binding_0, ) => {
+            AngleBracketed (
+                _visitor.fold_angle_bracketed_generic_arguments(_binding_0),
+            )
+        }
+        Parenthesized(_binding_0, ) => {
+            Parenthesized (
+                _visitor.fold_parenthesized_generic_arguments(_binding_0),
+            )
+        }
+    }
+}
 # [ cfg ( feature = "full" ) ]
 pub fn fold_path_glob<V: Folder + ?Sized>(_visitor: &mut V, _i: PathGlob) -> PathGlob {
     PathGlob {
@@ -2158,27 +2220,10 @@ pub fn fold_path_list_item<V: Folder + ?Sized>(_visitor: &mut V, _i: PathListIte
     }
 }
 
-pub fn fold_path_parameters<V: Folder + ?Sized>(_visitor: &mut V, _i: PathParameters) -> PathParameters {
-    use ::PathParameters::*;
-    match _i {
-        None => { None }
-        AngleBracketed(_binding_0, ) => {
-            AngleBracketed (
-                _visitor.fold_angle_bracketed_parameter_data(_binding_0),
-            )
-        }
-        Parenthesized(_binding_0, ) => {
-            Parenthesized (
-                _visitor.fold_parenthesized_parameter_data(_binding_0),
-            )
-        }
-    }
-}
-
 pub fn fold_path_segment<V: Folder + ?Sized>(_visitor: &mut V, _i: PathSegment) -> PathSegment {
     PathSegment {
         ident: _i . ident,
-        parameters: _visitor.fold_path_parameters(_i . parameters),
+        arguments: _visitor.fold_path_arguments(_i . arguments),
     }
 }
 # [ cfg ( feature = "full" ) ]

src/gen/visit.rs

@@ -35,7 +35,7 @@ fn visit_abi(&mut self, i: &'ast Abi) { visit_abi(self, i) }
 
 fn visit_abi_kind(&mut self, i: &'ast AbiKind) { visit_abi_kind(self, i) }
 
-fn visit_angle_bracketed_parameter_data(&mut self, i: &'ast AngleBracketedParameterData) { visit_angle_bracketed_parameter_data(self, i) }
+fn visit_angle_bracketed_generic_arguments(&mut self, i: &'ast AngleBracketedGenericArguments) { visit_angle_bracketed_generic_arguments(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_arg_captured(&mut self, i: &'ast ArgCaptured) { visit_arg_captured(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -70,6 +70,8 @@ fn visit_body_struct(&mut self, i: &'ast BodyStruct) { visit_body_struct(self, i
 fn visit_bound_lifetimes(&mut self, i: &'ast BoundLifetimes) { visit_bound_lifetimes(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_capture_by(&mut self, i: &'ast CaptureBy) { visit_capture_by(self, i) }
+
+fn visit_const_param(&mut self, i: &'ast ConstParam) { visit_const_param(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_constness(&mut self, i: &'ast Constness) { visit_constness(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -177,6 +179,8 @@ fn visit_foreign_item_static(&mut self, i: &'ast ForeignItemStatic) { visit_fore
 # [ cfg ( feature = "full" ) ]
 fn visit_foreign_item_type(&mut self, i: &'ast ForeignItemType) { visit_foreign_item_type(self, i) }
 
+fn visit_generic_argument(&mut self, i: &'ast GenericArgument) { visit_generic_argument(self, i) }
+
 fn visit_generic_param(&mut self, i: &'ast GenericParam) { visit_generic_param(self, i) }
 
 fn visit_generics(&mut self, i: &'ast Generics) { visit_generics(self, i) }
@@ -249,7 +253,7 @@ fn visit_mutability(&mut self, i: &'ast Mutability) { visit_mutability(self, i)
 
 fn visit_nested_meta_item(&mut self, i: &'ast NestedMetaItem) { visit_nested_meta_item(self, i) }
 
-fn visit_parenthesized_parameter_data(&mut self, i: &'ast ParenthesizedParameterData) { visit_parenthesized_parameter_data(self, i) }
+fn visit_parenthesized_generic_arguments(&mut self, i: &'ast ParenthesizedGenericArguments) { visit_parenthesized_generic_arguments(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_pat(&mut self, i: &'ast Pat) { visit_pat(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -276,15 +280,15 @@ fn visit_pat_tuple_struct(&mut self, i: &'ast PatTupleStruct) { visit_pat_tuple_
 fn visit_pat_wild(&mut self, i: &'ast PatWild) { visit_pat_wild(self, i) }
 
 fn visit_path(&mut self, i: &'ast Path) { visit_path(self, i) }
+
+fn visit_path_arguments(&mut self, i: &'ast PathArguments) { visit_path_arguments(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_path_glob(&mut self, i: &'ast PathGlob) { visit_path_glob(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_path_list(&mut self, i: &'ast PathList) { visit_path_list(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_path_list_item(&mut self, i: &'ast PathListItem) { visit_path_list_item(self, i) }
 
-fn visit_path_parameters(&mut self, i: &'ast PathParameters) { visit_path_parameters(self, i) }
-
 fn visit_path_segment(&mut self, i: &'ast PathSegment) { visit_path_segment(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_path_simple(&mut self, i: &'ast PathSimple) { visit_path_simple(self, i) }
@@ -393,12 +397,10 @@ pub fn visit_abi_kind<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     }
 }
 
-pub fn visit_angle_bracketed_parameter_data<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast AngleBracketedParameterData) {
+pub fn visit_angle_bracketed_generic_arguments<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast AngleBracketedGenericArguments) {
     // Skipped field _i . turbofish;
     // Skipped field _i . lt_token;
-    // Skipped field _i . lifetimes;
-    for el in (_i . types).iter() { let it = el.item(); _visitor.visit_type(&it) };
-    for el in (_i . bindings).iter() { let it = el.item(); _visitor.visit_type_binding(&it) };
+    for el in (_i . args).iter() { let it = el.item(); _visitor.visit_generic_argument(&it) };
     // Skipped field _i . gt_token;
 }
 # [ cfg ( feature = "full" ) ]
@@ -625,6 +627,16 @@ pub fn visit_capture_by<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &
         Ref => { }
     }
 }
+
+pub fn visit_const_param<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ConstParam) {
+    for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
+    // Skipped field _i . const_token;
+    // Skipped field _i . ident;
+    // Skipped field _i . colon_token;
+    _visitor.visit_type(&_i . ty);
+    // Skipped field _i . eq_token;
+    if let Some(ref it) = _i . default { _visitor.visit_expr(&* it) };
+}
 # [ cfg ( feature = "full" ) ]
 pub fn visit_constness<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Constness) {
     use ::Constness::*;
@@ -1131,6 +1143,24 @@ pub fn visit_foreign_item_type<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V
     // Skipped field _i . semi_token;
 }
 
+pub fn visit_generic_argument<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast GenericArgument) {
+    use ::GenericArgument::*;
+    match *_i {
+        Lifetime(ref _binding_0, ) => {
+            // Skipped field * _binding_0;
+        }
+        Type(ref _binding_0, ) => {
+            _visitor.visit_type(&* _binding_0);
+        }
+        TypeBinding(ref _binding_0, ) => {
+            _visitor.visit_type_binding(&* _binding_0);
+        }
+        Const(ref _binding_0, ) => {
+            full!(_visitor.visit_expr_block(&* _binding_0));
+        }
+    }
+}
+
 pub fn visit_generic_param<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast GenericParam) {
     use ::GenericParam::*;
     match *_i {
@@ -1140,6 +1170,9 @@ pub fn visit_generic_param<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i
         Type(ref _binding_0, ) => {
             _visitor.visit_type_param(&* _binding_0);
         }
+        Const(ref _binding_0, ) => {
+            _visitor.visit_const_param(&* _binding_0);
+        }
     }
 }
 
@@ -1527,7 +1560,7 @@ pub fn visit_nested_meta_item<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V,
     }
 }
 
-pub fn visit_parenthesized_parameter_data<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ParenthesizedParameterData) {
+pub fn visit_parenthesized_generic_arguments<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ParenthesizedGenericArguments) {
     // Skipped field _i . paren_token;
     for el in (_i . inputs).iter() { let it = el.item(); _visitor.visit_type(&it) };
     _visitor.visit_return_type(&_i . output);
@@ -1645,6 +1678,19 @@ pub fn visit_path<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast P
     // Skipped field _i . leading_colon;
     for el in (_i . segments).iter() { let it = el.item(); _visitor.visit_path_segment(&it) };
 }
+
+pub fn visit_path_arguments<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PathArguments) {
+    use ::PathArguments::*;
+    match *_i {
+        None => { }
+        AngleBracketed(ref _binding_0, ) => {
+            _visitor.visit_angle_bracketed_generic_arguments(&* _binding_0);
+        }
+        Parenthesized(ref _binding_0, ) => {
+            _visitor.visit_parenthesized_generic_arguments(&* _binding_0);
+        }
+    }
+}
 # [ cfg ( feature = "full" ) ]
 pub fn visit_path_glob<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PathGlob) {
     _visitor.visit_path(&_i . path);
@@ -1665,22 +1711,9 @@ pub fn visit_path_list_item<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _
     // Skipped field _i . as_token;
 }
 
-pub fn visit_path_parameters<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PathParameters) {
-    use ::PathParameters::*;
-    match *_i {
-        None => { }
-        AngleBracketed(ref _binding_0, ) => {
-            _visitor.visit_angle_bracketed_parameter_data(&* _binding_0);
-        }
-        Parenthesized(ref _binding_0, ) => {
-            _visitor.visit_parenthesized_parameter_data(&* _binding_0);
-        }
-    }
-}
-
 pub fn visit_path_segment<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PathSegment) {
     // Skipped field _i . ident;
-    _visitor.visit_path_parameters(&_i . parameters);
+    _visitor.visit_path_arguments(&_i . arguments);
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_path_simple<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PathSimple) {