1
1
use proc_macro2:: Ident ;
2
+ use syn:: parse:: Parse ;
3
+ use syn:: punctuated:: Punctuated ;
4
+ use syn:: token:: Comma ;
2
5
use syn:: Attribute ;
3
- use syn:: Meta :: List ;
4
- use syn:: Meta :: NameValue ;
5
- use syn:: NestedMeta :: Meta ;
6
+ use syn:: MetaNameValue ;
6
7
use syn:: Type ;
7
8
8
9
use crate :: symbol:: FILE_NAME ;
@@ -30,24 +31,22 @@ impl<'a> Container<'a> {
30
31
. flat_map ( |attr| get_ts_meta_items ( attr) )
31
32
. flatten ( )
32
33
{
33
- match meta_item {
34
- Meta ( NameValue ( m) ) if m. path == RENAME_ALL => {
35
- let s = get_lit_str ( & m. lit ) . expect ( "rename_all requires lit str" ) ;
36
- let t = match s. value ( ) . as_str ( ) {
37
- "camelCase" => RenameAll :: CamelCase ,
38
- _ => panic ! ( "unexpected literal for case converting" ) ,
39
- } ;
40
- rename_all = Some ( t) ;
41
- }
42
- Meta ( NameValue ( m) ) if m. path == FILE_NAME => {
43
- let s = get_lit_str ( & m. lit ) . expect ( "file_name requires lit str" ) ;
44
- file_name = Some ( s. value ( ) ) ;
45
- }
46
- Meta ( NameValue ( m) ) if m. path == RENAME => {
47
- let s = get_lit_str ( & m. lit ) . expect ( "rename requires lit str" ) ;
48
- rename = Some ( s. value ( ) ) ;
49
- }
50
- _ => panic ! ( "unexpected attr" ) ,
34
+ let m = meta_item;
35
+ if m. path == RENAME_ALL {
36
+ let s = get_lit_str ( & m. value ) . expect ( "rename_all requires lit str" ) ;
37
+ let t = match s. value ( ) . as_str ( ) {
38
+ "camelCase" => RenameAll :: CamelCase ,
39
+ _ => panic ! ( "unexpected literal for case converting" ) ,
40
+ } ;
41
+ rename_all = Some ( t) ;
42
+ } else if m. path == FILE_NAME {
43
+ let s = get_lit_str ( & m. value ) . expect ( "file_name requires lit str" ) ;
44
+ file_name = Some ( s. value ( ) ) ;
45
+ } else if m. path == RENAME {
46
+ let s = get_lit_str ( & m. value ) . expect ( "rename requires lit str" ) ;
47
+ rename = Some ( s. value ( ) ) ;
48
+ } else {
49
+ panic ! ( "unexpected attr" )
51
50
}
52
51
}
53
52
match & item. data {
@@ -138,20 +137,17 @@ fn parse_attrs<'a>(attrs: &'a Vec<Attribute>) -> FieldAttrs {
138
137
. flat_map ( |attr| get_ts_meta_items ( attr) )
139
138
. flatten ( )
140
139
{
141
- match meta_item {
142
- Meta ( NameValue ( m) ) if m. path == RENAME => {
143
- if let Ok ( s) = get_lit_str ( & m. lit ) {
144
- rename = Some ( s. value ( ) ) ;
145
- }
140
+ let m = meta_item;
141
+ if m. path == RENAME {
142
+ if let Ok ( s) = get_lit_str ( & m. value ) {
143
+ rename = Some ( s. value ( ) ) ;
146
144
}
147
- Meta ( NameValue ( m) ) if m. path == SKIP => {
148
- if let Ok ( s) = get_lit_bool ( & m. lit ) {
149
- skip = s;
150
- } else {
151
- panic ! ( "expected bool value in skip attr" )
152
- }
145
+ } else if m. path == SKIP {
146
+ if let Ok ( s) = get_lit_bool ( & m. value ) {
147
+ skip = s;
148
+ } else {
149
+ panic ! ( "expected bool value in skip attr" )
153
150
}
154
- _ => { }
155
151
}
156
152
}
157
153
FieldAttrs { skip, rename }
@@ -166,41 +162,42 @@ pub enum RenameAll {
166
162
CamelCase ,
167
163
}
168
164
169
- fn get_ts_meta_items ( attr : & syn:: Attribute ) -> Result < Vec < syn:: NestedMeta > , ( ) > {
170
- if attr. path != TS {
165
+ fn get_ts_meta_items ( attr : & syn:: Attribute ) -> Result < Vec < syn:: MetaNameValue > , ( ) > {
166
+ if attr. path ( ) != TS {
171
167
return Ok ( Vec :: new ( ) ) ;
172
168
}
173
169
174
- match attr. parse_meta ( ) {
175
- Ok ( List ( meta) ) => Ok ( meta. nested . into_iter ( ) . collect ( ) ) ,
176
- Ok ( _) => Err ( ( ) ) ,
170
+ match attr. parse_args_with ( Punctuated :: < MetaNameValue , Comma > :: parse_terminated) {
171
+ Ok ( name_values) => Ok ( name_values. into_iter ( ) . collect ( ) ) ,
177
172
Err ( _) => Err ( ( ) ) ,
178
173
}
179
174
}
180
175
181
- fn get_lit_str < ' a > ( lit : & ' a syn:: Lit ) -> Result < & ' a syn:: LitStr , ( ) > {
182
- if let syn:: Lit :: Str ( lit) = lit {
183
- Ok ( lit )
184
- } else {
185
- Err ( ( ) )
176
+ fn get_lit_str < ' a > ( lit : & ' a syn:: Expr ) -> Result < & ' a syn:: LitStr , ( ) > {
177
+ if let syn:: Expr :: Lit ( lit) = lit {
178
+ if let syn :: Lit :: Str ( l ) = & lit . lit {
179
+ return Ok ( & l ) ;
180
+ }
186
181
}
182
+ Err ( ( ) )
187
183
}
188
184
189
- fn get_lit_bool < ' a > ( lit : & ' a syn:: Lit ) -> Result < bool , ( ) > {
190
- if let syn:: Lit :: Bool ( b ) = lit {
191
- Ok ( b . value )
192
- } else {
193
- Err ( ( ) )
185
+ fn get_lit_bool < ' a > ( lit : & ' a syn:: Expr ) -> Result < bool , ( ) > {
186
+ if let syn:: Expr :: Lit ( lit ) = lit {
187
+ if let syn :: Lit :: Bool ( b ) = & lit . lit {
188
+ return Ok ( b . value ) ;
189
+ }
194
190
}
191
+ Err ( ( ) )
195
192
}
196
193
197
194
fn parse_comments ( attrs : & [ Attribute ] ) -> Vec < String > {
198
195
let mut result = Vec :: new ( ) ;
199
196
200
197
attrs. iter ( ) . for_each ( |attr| {
201
- if attr. path . is_ident ( "doc" ) {
202
- if let Ok ( NameValue ( nv) ) = & attr. parse_meta ( ) {
203
- if let Ok ( s) = get_lit_str ( & nv. lit ) {
198
+ if attr. path ( ) . is_ident ( "doc" ) {
199
+ if let Ok ( nv) = attr. meta . require_name_value ( ) {
200
+ if let Ok ( s) = get_lit_str ( & nv. value ) {
204
201
let comment = s. value ( ) ;
205
202
result. push ( comment. trim ( ) . to_string ( ) ) ;
206
203
}
@@ -209,3 +206,38 @@ fn parse_comments(attrs: &[Attribute]) -> Vec<String> {
209
206
} ) ;
210
207
result
211
208
}
209
+
210
+ pub ( crate ) struct GentsWasmAttrs {
211
+ file_name : String ,
212
+ }
213
+
214
+ impl GentsWasmAttrs {
215
+ pub fn get_file_name ( & self ) -> & str {
216
+ & self . file_name
217
+ }
218
+ }
219
+
220
+ impl Parse for GentsWasmAttrs {
221
+ fn parse ( input : syn:: parse:: ParseStream ) -> syn:: Result < Self > {
222
+ let name_values = Punctuated :: < MetaNameValue , Comma > :: parse_terminated ( input) ?;
223
+ let mut file_name = String :: new ( ) ;
224
+ name_values. into_iter ( ) . for_each ( |name_value| {
225
+ let path = name_value. path ;
226
+ let attr = path
227
+ . get_ident ( )
228
+ . expect ( "unvalid attr, should be an ident" )
229
+ . to_string ( ) ;
230
+ let value = get_lit_str ( & name_value. value )
231
+ . expect ( "should be a str" )
232
+ . value ( ) ;
233
+ match attr. as_str ( ) {
234
+ "file_name" => file_name = value,
235
+ _ => panic ! ( "invalid attr: {}" , attr) ,
236
+ }
237
+ } ) ;
238
+ if file_name. is_empty ( ) {
239
+ panic ! ( "file_name unset" )
240
+ }
241
+ Ok ( GentsWasmAttrs { file_name } )
242
+ }
243
+ }
0 commit comments