@@ -171,73 +171,70 @@ fn impl_extras(target: &DeriveInput) -> Result<TokenStream, Error> {
171
171
Data :: Struct ( ref data) => {
172
172
for field in & data. fields {
173
173
let attrs = GcFieldAttrs :: find ( & field. attrs ) ?;
174
- match attrs. mutable {
175
- Some ( mutable_opts) => {
176
- let original_name = match field. ident {
177
- Some ( ref name) => name,
178
- None => {
179
- return Err ( Error :: new (
180
- field. span ( ) ,
181
- "zerogc can only mutate named fields"
182
- ) )
183
- }
184
- } ;
185
- // Generate a mutator
186
- let mutator_name = Ident :: new (
187
- & format ! ( "set_{}" , original_name) ,
188
- field. ident . span ( ) ,
189
- ) ;
190
- let mutator_vis = if mutable_opts. public {
191
- quote ! ( pub )
192
- } else {
193
- quote ! ( )
194
- } ;
195
- let value_ref_type = match field. ty {
196
- Type :: Path ( ref cell_path) if cell_path. path . segments . last ( )
197
- . map_or ( false , |seg| seg. ident == "GcCell" ) => {
198
- let last_segment = cell_path. path . segments . last ( ) . unwrap ( ) ;
199
- let mut inner_type = None ;
200
- if let PathArguments :: AngleBracketed ( ref bracketed) = last_segment. arguments {
201
- for arg in & bracketed. args {
202
- match arg {
203
- GenericArgument :: Type ( t) if inner_type. is_none ( ) => {
204
- inner_type = Some ( t. clone ( ) ) ; // Initialize
205
- } ,
206
- _ => {
207
- inner_type = None ; // Unexpected arg
208
- break
209
- }
174
+ if let Some ( mutable_opts) = attrs. mutable {
175
+ let original_name = match field. ident {
176
+ Some ( ref name) => name,
177
+ None => {
178
+ return Err ( Error :: new (
179
+ field. span ( ) ,
180
+ "zerogc can only mutate named fields"
181
+ ) )
182
+ }
183
+ } ;
184
+ // Generate a mutator
185
+ let mutator_name = Ident :: new (
186
+ & format ! ( "set_{}" , original_name) ,
187
+ field. ident . span ( ) ,
188
+ ) ;
189
+ let mutator_vis = if mutable_opts. public {
190
+ quote ! ( pub )
191
+ } else {
192
+ quote ! ( )
193
+ } ;
194
+ let value_ref_type = match field. ty {
195
+ Type :: Path ( ref cell_path) if cell_path. path . segments . last ( )
196
+ . map_or ( false , |seg| seg. ident == "GcCell" ) => {
197
+ let last_segment = cell_path. path . segments . last ( ) . unwrap ( ) ;
198
+ let mut inner_type = None ;
199
+ if let PathArguments :: AngleBracketed ( ref bracketed) = last_segment. arguments {
200
+ for arg in & bracketed. args {
201
+ match arg {
202
+ GenericArgument :: Type ( t) if inner_type. is_none ( ) => {
203
+ inner_type = Some ( t. clone ( ) ) ; // Initialize
204
+ } ,
205
+ _ => {
206
+ inner_type = None ; // Unexpected arg
207
+ break
210
208
}
211
209
}
212
210
}
213
- inner_type. ok_or_else ( || Error :: new (
214
- field. ty . span ( ) ,
215
- "GcCell should have one (and only one) type param"
216
- ) ) ?
217
- } ,
218
- _ => return Err ( Error :: new (
211
+ }
212
+ inner_type. ok_or_else ( || Error :: new (
219
213
field. ty . span ( ) ,
220
- "A mutable field must be wrapped in a `GcCell`"
221
- ) )
222
- } ;
223
- // NOTE: Specially quoted since we want to blame the field for errors
224
- let field_as_ptr = quote_spanned ! ( field. span( ) => GcCell :: as_ptr( & ( * self . value( ) ) . #original_name) ) ;
225
- let barrier = quote_spanned ! ( field. span( ) => :: zerogc:: GcDirectBarrier :: write_barrier( & value, & self , offset) ) ;
226
- extra_items. push ( quote ! {
227
- #[ inline] // TODO: Implement `GcDirectBarrier` ourselves
228
- #mutator_vis fn #mutator_name<OwningRef >( self : OwningRef , value: #value_ref_type)
229
- where OwningRef : :: zerogc:: GcRef <' gc, Self >,
230
- #value_ref_type: :: zerogc:: GcDirectBarrier <' gc, OwningRef > {
231
- unsafe {
232
- let target_ptr = #field_as_ptr;
233
- let offset = target_ptr as usize - self . as_raw_ptr( ) as usize ;
234
- #barrier;
235
- target_ptr. write( value) ;
236
- }
214
+ "GcCell should have one (and only one) type param"
215
+ ) ) ?
216
+ } ,
217
+ _ => return Err ( Error :: new (
218
+ field. ty . span ( ) ,
219
+ "A mutable field must be wrapped in a `GcCell`"
220
+ ) )
221
+ } ;
222
+ // NOTE: Specially quoted since we want to blame the field for errors
223
+ let field_as_ptr = quote_spanned ! ( field. span( ) => GcCell :: as_ptr( & ( * self . value( ) ) . #original_name) ) ;
224
+ let barrier = quote_spanned ! ( field. span( ) => :: zerogc:: GcDirectBarrier :: write_barrier( & value, & self , offset) ) ;
225
+ extra_items. push ( quote ! {
226
+ #[ inline] // TODO: Implement `GcDirectBarrier` ourselves
227
+ #mutator_vis fn #mutator_name<OwningRef >( self : OwningRef , value: #value_ref_type)
228
+ where OwningRef : :: zerogc:: GcRef <' gc, Self >,
229
+ #value_ref_type: :: zerogc:: GcDirectBarrier <' gc, OwningRef > {
230
+ unsafe {
231
+ let target_ptr = #field_as_ptr;
232
+ let offset = target_ptr as usize - self . as_raw_ptr( ) as usize ;
233
+ #barrier;
234
+ target_ptr. write( value) ;
237
235
}
238
- } )
239
- }
240
- None => { }
236
+ }
237
+ } )
241
238
}
242
239
}
243
240
} ,
0 commit comments