@@ -10,7 +10,7 @@ pub enum Argument {
10
10
Kwarg ( String , String ) ,
11
11
}
12
12
13
- pub fn parse_arguments ( items : & [ syn:: NestedMetaItem ] ) -> Vec < Argument > {
13
+ pub fn parse_arguments ( items : & [ syn:: NestedMeta ] ) -> Vec < Argument > {
14
14
let mut arguments = Vec :: new ( ) ;
15
15
let mut has_kw = false ;
16
16
let mut has_varargs = false ;
@@ -22,7 +22,7 @@ pub fn parse_arguments(items: &[syn::NestedMetaItem]) -> Vec<Argument> {
22
22
23
23
for item in items. iter ( ) {
24
24
match item {
25
- & syn:: NestedMetaItem :: MetaItem ( syn:: MetaItem :: Word ( ref ident) ) => {
25
+ & syn:: NestedMeta :: Meta ( syn:: Meta :: Word ( ref ident) ) => {
26
26
// arguments in form #[args(somename)]
27
27
if has_kwargs {
28
28
println ! ( "syntax error, keyword arguments is defined: {:?}" , args_str) ;
@@ -35,11 +35,11 @@ pub fn parse_arguments(items: &[syn::NestedMetaItem]) -> Vec<Argument> {
35
35
}
36
36
arguments. push ( Argument :: Arg ( ident. as_ref ( ) . to_owned ( ) , None ) )
37
37
}
38
- & syn:: NestedMetaItem :: MetaItem ( syn:: MetaItem :: NameValue ( ref ident , ref lit ) ) => {
39
- let name = ident. as_ref ( ) . to_owned ( ) ;
40
- match lit {
41
- & syn:: Lit :: Str ( ref s , _ ) => {
42
- if s == "*" { // #[args(args="*")]
38
+ & syn:: NestedMeta :: Meta ( syn:: Meta :: NameValue ( ref nv ) ) => {
39
+ let name = nv . ident . as_ref ( ) . to_owned ( ) ;
40
+ match nv . lit {
41
+ syn:: Lit :: Str ( ref litstr ) => {
42
+ if litstr . value ( ) == "*" { // #[args(args="*")]
43
43
if has_kwargs {
44
44
println ! ( "* - syntax error, keyword arguments is defined: {:?}" ,
45
45
args_str) ;
@@ -51,8 +51,7 @@ pub fn parse_arguments(items: &[syn::NestedMetaItem]) -> Vec<Argument> {
51
51
}
52
52
has_varargs = true ;
53
53
arguments. push ( Argument :: VarArgs ( name) ) ;
54
- }
55
- else if s == "**" { // #[args(kwargs="**")]
54
+ } else if litstr. value ( ) == "**" { // #[args(kwargs="**")]
56
55
if has_kwargs {
57
56
println ! ( "arguments already define ** (kw args): {:?}" ,
58
57
args_str) ;
@@ -62,55 +61,55 @@ pub fn parse_arguments(items: &[syn::NestedMetaItem]) -> Vec<Argument> {
62
61
arguments. push ( Argument :: KeywordArgs ( name) ) ;
63
62
} else {
64
63
if has_varargs {
65
- arguments. push ( Argument :: Kwarg ( name, s . clone ( ) ) )
64
+ arguments. push ( Argument :: Kwarg ( name, litstr . value ( ) . clone ( ) ) )
66
65
} else {
67
66
if has_kwargs {
68
67
println ! ( "syntax error, keyword arguments is defined: {:?}" ,
69
68
args_str) ;
70
69
return Vec :: new ( )
71
70
}
72
71
has_kw = true ;
73
- arguments. push ( Argument :: Arg ( name, Some ( s . clone ( ) ) ) )
72
+ arguments. push ( Argument :: Arg ( name, Some ( litstr . value ( ) . clone ( ) ) ) )
74
73
}
75
74
}
76
75
}
77
- & syn:: Lit :: Int ( ref s , _ ) => {
76
+ syn:: Lit :: Int ( ref litint ) => {
78
77
if has_varargs {
79
- arguments. push ( Argument :: Kwarg ( name, format ! ( "{}" , s ) ) ) ;
78
+ arguments. push ( Argument :: Kwarg ( name, format ! ( "{}" , litint . value ( ) ) ) ) ;
80
79
} else {
81
80
if has_kwargs {
82
81
println ! ( "syntax error, keyword arguments is defined: {:?}" ,
83
82
args_str) ;
84
83
return Vec :: new ( )
85
84
}
86
85
has_kw = true ;
87
- arguments. push ( Argument :: Arg ( name, Some ( format ! ( "{}" , s ) ) ) ) ;
86
+ arguments. push ( Argument :: Arg ( name, Some ( format ! ( "{}" , litint . value ( ) ) ) ) ) ;
88
87
}
89
88
}
90
- & syn:: Lit :: Bool ( ref b ) => {
89
+ syn:: Lit :: Bool ( ref litb ) => {
91
90
if has_varargs {
92
- arguments. push ( Argument :: Kwarg ( name, format ! ( "{}" , b ) ) ) ;
91
+ arguments. push ( Argument :: Kwarg ( name, format ! ( "{}" , litb . value ) ) ) ;
93
92
} else {
94
93
if has_kwargs {
95
94
println ! ( "syntax error, keyword arguments is defined: {:?}" ,
96
95
args_str) ;
97
96
return Vec :: new ( )
98
97
}
99
98
has_kw = true ;
100
- arguments. push ( Argument :: Arg ( name, Some ( format ! ( "{}" , b ) ) ) ) ;
99
+ arguments. push ( Argument :: Arg ( name, Some ( format ! ( "{}" , litb . value ) ) ) ) ;
101
100
}
102
101
}
103
102
_ => {
104
- println ! ( "Only string literal is supported, got: {:?}" , lit) ;
103
+ println ! ( "Only string literal is supported, got: {:?}" , nv . lit) ;
105
104
return Vec :: new ( )
106
105
}
107
106
}
108
107
}
109
- & syn:: NestedMetaItem :: Literal ( ref lit) => {
108
+ & syn:: NestedMeta :: Literal ( ref lit) => {
110
109
match lit {
111
- & syn:: Lit :: Str ( ref s , _ ) => {
110
+ & syn:: Lit :: Str ( ref lits ) => {
112
111
// #[args("*")]
113
- if s == "*" {
112
+ if lits . value ( ) == "*" {
114
113
if has_kwargs {
115
114
println ! (
116
115
"syntax error, keyword arguments is defined: {:?}" ,
@@ -127,7 +126,7 @@ pub fn parse_arguments(items: &[syn::NestedMetaItem]) -> Vec<Argument> {
127
126
arguments. push ( Argument :: VarArgsSeparator ) ;
128
127
} else {
129
128
println ! ( "Unknown string literal, got: {:?} args: {:?}" ,
130
- s , args_str) ;
129
+ lits . value ( ) , args_str) ;
131
130
return Vec :: new ( )
132
131
}
133
132
}
@@ -154,11 +153,11 @@ mod test {
154
153
use syn;
155
154
use args:: { Argument , parse_arguments} ;
156
155
157
- fn items ( s : & ' static str ) -> Vec < syn:: NestedMetaItem > {
156
+ fn items ( s : & ' static str ) -> Vec < syn:: NestedMeta > {
158
157
let i = syn:: parse_outer_attr ( s) . unwrap ( ) ;
159
158
160
159
match i. value {
161
- syn:: MetaItem :: List ( _, items) => {
160
+ syn:: Meta :: List ( _, items) => {
162
161
items
163
162
}
164
163
_ => unreachable ! ( )
0 commit comments