Improve the consistency of type naming
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index 6b61ccc..6a6dddc 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -62,7 +62,7 @@
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" ) ]
@@ -204,7 +204,7 @@
# [ cfg ( feature = "full" ) ]
fn fold_foreign_item_type(&mut self, i: ForeignItemType) -> ForeignItemType { fold_foreign_item_type(self, i) }
-fn fold_generic_arg(&mut self, i: GenericArg) -> GenericArg { fold_generic_arg(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) }
@@ -278,7 +278,7 @@
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" ) ]
@@ -305,6 +305,8 @@
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" ) ]
@@ -312,8 +314,6 @@
# [ 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) }
@@ -426,11 +426,11 @@
}
}
-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,
- args: FoldHelper::lift(_i . args, |it| { _visitor.fold_generic_arg(it) }),
+ args: FoldHelper::lift(_i . args, |it| { _visitor.fold_generic_argument(it) }),
gt_token: _i . gt_token,
}
}
@@ -1452,8 +1452,8 @@
}
}
-pub fn fold_generic_arg<V: Folder + ?Sized>(_visitor: &mut V, _i: GenericArg) -> GenericArg {
- use ::GenericArg::*;
+pub fn fold_generic_argument<V: Folder + ?Sized>(_visitor: &mut V, _i: GenericArgument) -> GenericArgument {
+ use ::GenericArgument::*;
match _i {
Lifetime(_binding_0, ) => {
Lifetime (
@@ -1985,8 +1985,8 @@
}
}
-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),
@@ -2153,6 +2153,23 @@
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 {
@@ -2179,27 +2196,10 @@
}
}
-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" ) ]
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index 72f2861..efe7b47 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -35,7 +35,7 @@
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" ) ]
@@ -177,7 +177,7 @@
# [ cfg ( feature = "full" ) ]
fn visit_foreign_item_type(&mut self, i: &'ast ForeignItemType) { visit_foreign_item_type(self, i) }
-fn visit_generic_arg(&mut self, i: &'ast GenericArg) { visit_generic_arg(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) }
@@ -251,7 +251,7 @@
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" ) ]
@@ -278,6 +278,8 @@
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" ) ]
@@ -285,8 +287,6 @@
# [ 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) }
@@ -395,10 +395,10 @@
}
}
-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;
- for el in (_i . args).iter() { let it = el.item(); _visitor.visit_generic_arg(&it) };
+ for el in (_i . args).iter() { let it = el.item(); _visitor.visit_generic_argument(&it) };
// Skipped field _i . gt_token;
}
# [ cfg ( feature = "full" ) ]
@@ -1131,8 +1131,8 @@
// Skipped field _i . semi_token;
}
-pub fn visit_generic_arg<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast GenericArg) {
- use ::GenericArg::*;
+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;
@@ -1542,7 +1542,7 @@
}
}
-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);
@@ -1660,6 +1660,19 @@
// 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);
@@ -1680,22 +1693,9 @@
// 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) {
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 2a4cb11..77eaaca 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -35,7 +35,7 @@
fn visit_abi_kind_mut(&mut self, i: &mut AbiKind) { visit_abi_kind_mut(self, i) }
-fn visit_angle_bracketed_parameter_data_mut(&mut self, i: &mut AngleBracketedParameterData) { visit_angle_bracketed_parameter_data_mut(self, i) }
+fn visit_angle_bracketed_generic_arguments_mut(&mut self, i: &mut AngleBracketedGenericArguments) { visit_angle_bracketed_generic_arguments_mut(self, i) }
# [ cfg ( feature = "full" ) ]
fn visit_arg_captured_mut(&mut self, i: &mut ArgCaptured) { visit_arg_captured_mut(self, i) }
# [ cfg ( feature = "full" ) ]
@@ -177,7 +177,7 @@
# [ cfg ( feature = "full" ) ]
fn visit_foreign_item_type_mut(&mut self, i: &mut ForeignItemType) { visit_foreign_item_type_mut(self, i) }
-fn visit_generic_arg_mut(&mut self, i: &mut GenericArg) { visit_generic_arg_mut(self, i) }
+fn visit_generic_argument_mut(&mut self, i: &mut GenericArgument) { visit_generic_argument_mut(self, i) }
fn visit_generic_param_mut(&mut self, i: &mut GenericParam) { visit_generic_param_mut(self, i) }
@@ -251,7 +251,7 @@
fn visit_nested_meta_item_mut(&mut self, i: &mut NestedMetaItem) { visit_nested_meta_item_mut(self, i) }
-fn visit_parenthesized_parameter_data_mut(&mut self, i: &mut ParenthesizedParameterData) { visit_parenthesized_parameter_data_mut(self, i) }
+fn visit_parenthesized_generic_arguments_mut(&mut self, i: &mut ParenthesizedGenericArguments) { visit_parenthesized_generic_arguments_mut(self, i) }
# [ cfg ( feature = "full" ) ]
fn visit_pat_mut(&mut self, i: &mut Pat) { visit_pat_mut(self, i) }
# [ cfg ( feature = "full" ) ]
@@ -278,6 +278,8 @@
fn visit_pat_wild_mut(&mut self, i: &mut PatWild) { visit_pat_wild_mut(self, i) }
fn visit_path_mut(&mut self, i: &mut Path) { visit_path_mut(self, i) }
+
+fn visit_path_arguments_mut(&mut self, i: &mut PathArguments) { visit_path_arguments_mut(self, i) }
# [ cfg ( feature = "full" ) ]
fn visit_path_glob_mut(&mut self, i: &mut PathGlob) { visit_path_glob_mut(self, i) }
# [ cfg ( feature = "full" ) ]
@@ -285,8 +287,6 @@
# [ cfg ( feature = "full" ) ]
fn visit_path_list_item_mut(&mut self, i: &mut PathListItem) { visit_path_list_item_mut(self, i) }
-fn visit_path_parameters_mut(&mut self, i: &mut PathParameters) { visit_path_parameters_mut(self, i) }
-
fn visit_path_segment_mut(&mut self, i: &mut PathSegment) { visit_path_segment_mut(self, i) }
# [ cfg ( feature = "full" ) ]
fn visit_path_simple_mut(&mut self, i: &mut PathSimple) { visit_path_simple_mut(self, i) }
@@ -395,10 +395,10 @@
}
}
-pub fn visit_angle_bracketed_parameter_data_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut AngleBracketedParameterData) {
+pub fn visit_angle_bracketed_generic_arguments_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut AngleBracketedGenericArguments) {
// Skipped field _i . turbofish;
// Skipped field _i . lt_token;
- for mut el in (_i . args).iter_mut() { let mut it = el.item_mut(); _visitor.visit_generic_arg_mut(&mut it) };
+ for mut el in (_i . args).iter_mut() { let mut it = el.item_mut(); _visitor.visit_generic_argument_mut(&mut it) };
// Skipped field _i . gt_token;
}
# [ cfg ( feature = "full" ) ]
@@ -1131,8 +1131,8 @@
// Skipped field _i . semi_token;
}
-pub fn visit_generic_arg_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut GenericArg) {
- use ::GenericArg::*;
+pub fn visit_generic_argument_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut GenericArgument) {
+ use ::GenericArgument::*;
match *_i {
Lifetime(ref mut _binding_0, ) => {
// Skipped field * _binding_0;
@@ -1542,7 +1542,7 @@
}
}
-pub fn visit_parenthesized_parameter_data_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ParenthesizedParameterData) {
+pub fn visit_parenthesized_generic_arguments_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ParenthesizedGenericArguments) {
// Skipped field _i . paren_token;
for mut el in (_i . inputs).iter_mut() { let mut it = el.item_mut(); _visitor.visit_type_mut(&mut it) };
_visitor.visit_return_type_mut(&mut _i . output);
@@ -1660,6 +1660,19 @@
// Skipped field _i . leading_colon;
for mut el in (_i . segments).iter_mut() { let mut it = el.item_mut(); _visitor.visit_path_segment_mut(&mut it) };
}
+
+pub fn visit_path_arguments_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathArguments) {
+ use ::PathArguments::*;
+ match *_i {
+ None => { }
+ AngleBracketed(ref mut _binding_0, ) => {
+ _visitor.visit_angle_bracketed_generic_arguments_mut(&mut * _binding_0);
+ }
+ Parenthesized(ref mut _binding_0, ) => {
+ _visitor.visit_parenthesized_generic_arguments_mut(&mut * _binding_0);
+ }
+ }
+}
# [ cfg ( feature = "full" ) ]
pub fn visit_path_glob_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathGlob) {
_visitor.visit_path_mut(&mut _i . path);
@@ -1680,22 +1693,9 @@
// Skipped field _i . as_token;
}
-pub fn visit_path_parameters_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathParameters) {
- use ::PathParameters::*;
- match *_i {
- None => { }
- AngleBracketed(ref mut _binding_0, ) => {
- _visitor.visit_angle_bracketed_parameter_data_mut(&mut * _binding_0);
- }
- Parenthesized(ref mut _binding_0, ) => {
- _visitor.visit_parenthesized_parameter_data_mut(&mut * _binding_0);
- }
- }
-}
-
pub fn visit_path_segment_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathSegment) {
// Skipped field _i . ident;
- _visitor.visit_path_parameters_mut(&mut _i . parameters);
+ _visitor.visit_path_arguments_mut(&mut _i . arguments);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_path_simple_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathSimple) {
diff --git a/src/lib.rs b/src/lib.rs
index bd59686..707cbf6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -83,11 +83,13 @@
pub use op::{BinOp, UnOp};
mod ty;
-pub use ty::{Abi, AbiKind, AngleBracketedParameterData, BareFnArg, BareFnArgName, BareFnType,
- ReturnType, MutType, Mutability, ParenthesizedParameterData, Path,
- PathParameters, PathSegment, PolyTraitRef, QSelf, Type, TypeBinding, Unsafety,
- TypeSlice, TypeArray, TypePtr, TypeReference, TypeBareFn, TypeNever, TypeTup, TypePath,
- TypeTraitObject, TypeImplTrait, TypeParen, TypeInfer, TypeGroup, GenericArg};
+pub use ty::{Abi, AbiKind, AngleBracketedGenericArguments, BareFnArg,
+ BareFnArgName, BareFnType, ReturnType, MutType, Mutability,
+ ParenthesizedGenericArguments, Path, PathArguments, PathSegment,
+ PolyTraitRef, QSelf, Type, TypeBinding, Unsafety, TypeSlice,
+ TypeArray, TypePtr, TypeReference, TypeBareFn, TypeNever, TypeTup,
+ TypePath, TypeTraitObject, TypeImplTrait, TypeParen, TypeInfer,
+ TypeGroup, GenericArgument};
#[cfg(feature = "printing")]
pub use ty::PathTokens;
diff --git a/src/ty.rs b/src/ty.rs
index 77a43fb..413fe5b 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -45,7 +45,7 @@
/// A path (`module::module::...::Type`), optionally
/// "qualified", e.g. `<Vec<T> as SomeTrait>::SomeType`.
///
- /// Type parameters are stored in the Path itself
+ /// Type arguments are stored in the Path itself
pub Path(TypePath {
pub qself: Option<QSelf>,
pub path: Path,
@@ -141,12 +141,12 @@
pub struct PathSegment {
/// The identifier portion of this path segment.
pub ident: Ident,
- /// Type/lifetime parameters attached to this path. They come in
+ /// Type/lifetime arguments attached to this path. They come in
/// two flavors: `Path<A,B,C>` and `Path(A,B) -> C`. Note that
/// this is more than just simple syntactic sugar; the use of
/// parens affects the region binding rules, so we preserve the
/// distinction.
- pub parameters: PathParameters,
+ pub arguments: PathArguments,
}
}
@@ -156,43 +156,43 @@
fn from(ident: T) -> Self {
PathSegment {
ident: ident.into(),
- parameters: PathParameters::None,
+ arguments: PathArguments::None,
}
}
}
ast_enum! {
- /// Parameters of a path segment.
+ /// Arguments of a path segment.
///
/// E.g. `<A, B>` as in `Foo<A, B>` or `(A, B)` as in `Foo(A, B)`
- pub enum PathParameters {
+ pub enum PathArguments {
None,
/// The `<'a, A, B, C>` in `foo::bar::baz::<'a, A, B, C>`
- AngleBracketed(AngleBracketedParameterData),
+ AngleBracketed(AngleBracketedGenericArguments),
/// The `(A, B)` and `C` in `Foo(A, B) -> C`
- Parenthesized(ParenthesizedParameterData),
+ Parenthesized(ParenthesizedGenericArguments),
}
}
-impl Default for PathParameters {
+impl Default for PathArguments {
fn default() -> Self {
- PathParameters::None
+ PathArguments::None
}
}
-impl PathParameters {
+impl PathArguments {
pub fn is_empty(&self) -> bool {
match *self {
- PathParameters::None => true,
- PathParameters::AngleBracketed(ref bracketed) => bracketed.args.is_empty(),
- PathParameters::Parenthesized(_) => false,
+ PathArguments::None => true,
+ PathArguments::AngleBracketed(ref bracketed) => bracketed.args.is_empty(),
+ PathArguments::Parenthesized(_) => false,
}
}
}
ast_enum! {
/// A individual generic argument, like `'a`, `T`, or `Item=T`.
- pub enum GenericArg {
+ pub enum GenericArgument {
/// The lifetime parameters for this path segment.
Lifetime(Lifetime),
/// The type parameters for this path segment, if present.
@@ -206,10 +206,10 @@
ast_struct! {
/// A path like `Foo<'a, T>`
- pub struct AngleBracketedParameterData {
+ pub struct AngleBracketedGenericArguments {
pub turbofish: Option<Token![::]>,
pub lt_token: Token![<],
- pub args: Delimited<GenericArg, Token![,]>,
+ pub args: Delimited<GenericArgument, Token![,]>,
pub gt_token: Token![>],
}
}
@@ -226,7 +226,7 @@
ast_struct! {
/// A path like `Foo(A,B) -> C`
- pub struct ParenthesizedParameterData {
+ pub struct ParenthesizedGenericArguments {
pub paren_token: tokens::Paren,
/// `(A, B)`
pub inputs: Delimited<Type, Token![,]>,
@@ -515,8 +515,8 @@
named!(ty_path(allow_plus: bool) -> Type, do_parse!(
qpath: qpath >>
parenthesized: cond!(
- qpath.1.segments.get(qpath.1.segments.len() - 1).item().parameters.is_empty(),
- option!(syn!(ParenthesizedParameterData))
+ qpath.1.segments.get(qpath.1.segments.len() - 1).item().arguments.is_empty(),
+ option!(syn!(ParenthesizedGenericArguments))
) >>
// Only allow parsing additional bounds if allow_plus is true.
bounds: alt!(
@@ -530,9 +530,9 @@
({
let (qself, mut path) = qpath;
if let Some(Some(parenthesized)) = parenthesized {
- let parenthesized = PathParameters::Parenthesized(parenthesized);
+ let parenthesized = PathArguments::Parenthesized(parenthesized);
let len = path.segments.len();
- path.segments.get_mut(len - 1).item_mut().parameters = parenthesized;
+ path.segments.get_mut(len - 1).item_mut().arguments = parenthesized;
}
if bounds.is_empty() {
TypePath { qself: qself, path: path }.into()
@@ -600,11 +600,11 @@
map!(keyword!(self), |s| (None, s.into()))
));
- impl Synom for ParenthesizedParameterData {
+ impl Synom for ParenthesizedGenericArguments {
named!(parse -> Self, do_parse!(
data: parens!(call!(Delimited::parse_terminated)) >>
output: syn!(ReturnType) >>
- (ParenthesizedParameterData {
+ (ParenthesizedGenericArguments {
paren_token: data.1,
inputs: data.0,
output: output,
@@ -691,23 +691,23 @@
}
}
- impl Synom for GenericArg {
+ impl Synom for GenericArgument {
named!(parse -> Self, alt!(
- call!(ty_no_eq_after) => { GenericArg::Type }
+ call!(ty_no_eq_after) => { GenericArgument::Type }
|
- syn!(Lifetime) => { GenericArg::Lifetime }
+ syn!(Lifetime) => { GenericArgument::Lifetime }
|
- syn!(TypeBinding) => { GenericArg::TypeBinding }
+ syn!(TypeBinding) => { GenericArgument::TypeBinding }
));
}
- impl Synom for AngleBracketedParameterData {
+ impl Synom for AngleBracketedGenericArguments {
named!(parse -> Self, do_parse!(
turbofish: option!(punct!(::)) >>
lt: punct!(<) >>
args: call!(Delimited::parse_terminated) >>
gt: punct!(>) >>
- (AngleBracketedParameterData {
+ (AngleBracketedGenericArguments {
turbofish: turbofish,
lt_token: lt,
args: args,
@@ -720,10 +720,10 @@
named!(parse -> Self, alt!(
do_parse!(
ident: syn!(Ident) >>
- parameters: syn!(AngleBracketedParameterData) >>
+ arguments: syn!(AngleBracketedGenericArguments) >>
(PathSegment {
ident: ident,
- parameters: PathParameters::AngleBracketed(parameters),
+ arguments: PathArguments::AngleBracketed(arguments),
})
)
|
@@ -775,15 +775,15 @@
bound_lifetimes: option!(syn!(BoundLifetimes)) >>
trait_ref: syn!(Path) >>
parenthesized: option!(cond_reduce!(
- trait_ref.segments.get(trait_ref.segments.len() - 1).item().parameters.is_empty(),
- syn!(ParenthesizedParameterData)
+ trait_ref.segments.get(trait_ref.segments.len() - 1).item().arguments.is_empty(),
+ syn!(ParenthesizedGenericArguments)
)) >>
({
let mut trait_ref = trait_ref;
if let Some(parenthesized) = parenthesized {
- let parenthesized = PathParameters::Parenthesized(parenthesized);
+ let parenthesized = PathArguments::Parenthesized(parenthesized);
let len = trait_ref.segments.len();
- trait_ref.segments.get_mut(len - 1).item_mut().parameters = parenthesized;
+ trait_ref.segments.get_mut(len - 1).item_mut().arguments = parenthesized;
}
PolyTraitRef {
bound_lifetimes: bound_lifetimes,
@@ -1005,35 +1005,35 @@
impl ToTokens for PathSegment {
fn to_tokens(&self, tokens: &mut Tokens) {
self.ident.to_tokens(tokens);
- self.parameters.to_tokens(tokens);
+ self.arguments.to_tokens(tokens);
}
}
- impl ToTokens for PathParameters {
+ impl ToTokens for PathArguments {
fn to_tokens(&self, tokens: &mut Tokens) {
match *self {
- PathParameters::None => {}
- PathParameters::AngleBracketed(ref parameters) => {
- parameters.to_tokens(tokens);
+ PathArguments::None => {}
+ PathArguments::AngleBracketed(ref arguments) => {
+ arguments.to_tokens(tokens);
}
- PathParameters::Parenthesized(ref parameters) => {
- parameters.to_tokens(tokens);
+ PathArguments::Parenthesized(ref arguments) => {
+ arguments.to_tokens(tokens);
}
}
}
}
- impl ToTokens for GenericArg {
+ impl ToTokens for GenericArgument {
fn to_tokens(&self, tokens: &mut Tokens) {
match *self {
- GenericArg::Lifetime(ref lt) => lt.to_tokens(tokens),
- GenericArg::Type(ref ty) => ty.to_tokens(tokens),
- GenericArg::TypeBinding(ref tb) => tb.to_tokens(tokens),
+ GenericArgument::Lifetime(ref lt) => lt.to_tokens(tokens),
+ GenericArgument::Type(ref ty) => ty.to_tokens(tokens),
+ GenericArgument::TypeBinding(ref tb) => tb.to_tokens(tokens),
}
}
}
- impl ToTokens for AngleBracketedParameterData {
+ impl ToTokens for AngleBracketedGenericArguments {
fn to_tokens(&self, tokens: &mut Tokens) {
self.turbofish.to_tokens(tokens);
self.lt_token.to_tokens(tokens);
@@ -1050,7 +1050,7 @@
}
}
- impl ToTokens for ParenthesizedParameterData {
+ impl ToTokens for ParenthesizedGenericArguments {
fn to_tokens(&self, tokens: &mut Tokens) {
self.paren_token.surround(tokens, |tokens| {
self.inputs.to_tokens(tokens);
diff --git a/syn_codegen/src/main.rs b/syn_codegen/src/main.rs
index a1757d2..2a60844 100644
--- a/syn_codegen/src/main.rs
+++ b/syn_codegen/src/main.rs
@@ -308,15 +308,15 @@
Fold,
}
- fn first_param(params: &PathParameters) -> &Type {
+ fn first_arg(params: &PathArguments) -> &Type {
let data = match *params {
- PathParameters::AngleBracketed(ref data) => data,
- _ => panic!("Expected at least 1 type parameter here"),
+ PathArguments::AngleBracketed(ref data) => data,
+ _ => panic!("Expected at least 1 type argument here"),
};
- match *data.args.first().expect("Expected at least 1 type parameter here").item() {
- &GenericArg::Type(ref ty) => ty,
- _ => panic!("Expected at least 1 type parmeter here"),
+ match *data.args.first().expect("Expected at least 1 type argument here").item() {
+ &GenericArgument::Type(ref ty) => ty,
+ _ => panic!("Expected at least 1 type argument here"),
}
}
@@ -363,7 +363,7 @@
}
if seg.ident == "Box" {
- let ty = first_param(&seg.parameters);
+ let ty = first_arg(&seg.arguments);
if let Some(seg) = last_segment(ty) {
if kind == Kind::Fold {
let name = quote!(*#name);
@@ -398,7 +398,7 @@
if seg.ident == "Vec" || seg.ident == "Delimited" {
let is_vec = seg.ident == "Vec";
- let ty = first_param(&seg.parameters);
+ let ty = first_arg(&seg.arguments);
if let Some(seg) = last_segment(ty) {
if let Some(val) = box_visit(seg, lookup, kind, "e!(it), eos_full) {
return Some(match kind {
@@ -465,7 +465,7 @@
}
if seg.ident == "Option" {
- let ty = first_param(&seg.parameters);
+ let ty = first_arg(&seg.arguments);
if let Some(seg) = last_segment(ty) {
let it = match kind {
Kind::Fold => quote!(it),
diff --git a/tests/test_derive_input.rs b/tests/test_derive_input.rs
index c56d59a..a65472e 100644
--- a/tests/test_derive_input.rs
+++ b/tests/test_derive_input.rs
@@ -114,12 +114,12 @@
segments: vec![
PathSegment {
ident: "Vec".into(),
- parameters: PathParameters::AngleBracketed(
- AngleBracketedParameterData {
+ arguments: PathArguments::AngleBracketed(
+ AngleBracketedGenericArguments {
turbofish: None,
lt_token: Default::default(),
args: vec![
- GenericArg::Type(Type::from(TypePath {
+ GenericArgument::Type(Type::from(TypePath {
qself: None,
path: "Attribute".into(),
})),