Lines Matching refs:params

22     let params = Parameters::new(&cont);
23     let (impl_generics, ty_generics, where_clause) = params.generics.split_for_impl();
24     let body = Stmts(serialize_body(&cont, &params));
29         let used = pretend::pretend_used(&cont, params.is_packed);
166 fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
168         serialize_transparent(cont, params)
170         serialize_into(params, type_into)
173             Data::Enum(variants) => serialize_enum(params, variants, &cont.attrs),
174             Data::Struct(Style::Struct, fields) => serialize_struct(params, fields, &cont.attrs),
176                 serialize_tuple_struct(params, fields, &cont.attrs)
179                 serialize_newtype_struct(params, &fields[0], &cont.attrs)
186 fn serialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
192     let self_var = &params.self_var;
209 fn serialize_into(params: &Parameters, type_into: &syn::Type) -> Fragment {
210     let self_var = &params.self_var;
227     params: &Parameters,
234         params,
242         field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
253     params: &Parameters,
258         serialize_tuple_struct_visitor(fields, params, false, &TupleTrait::SerializeTupleStruct);
278                 let field_expr = get_member(params, field, &Member::Unnamed(index));
291 fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Container) -> Fragment {
295         serialize_struct_as_map(params, fields, cattrs)
297         serialize_struct_as_struct(params, fields, cattrs)
315     params: &Parameters,
320         serialize_struct_visitor(fields, params, false, &StructTrait::SerializeStruct);
338                 let field_expr = get_member(params, field, &field.member);
356     params: &Parameters,
361         serialize_struct_visitor(fields, params, false, &StructTrait::SerializeMap);
380                     let field_expr = get_member(params, field, &field.member);
399 fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Container) -> Fragment {
402     let self_var = &params.self_var;
408             serialize_variant(params, variant, variant_index as u32, cattrs)
426     params: &Parameters,
431     let this_value = &params.this_value;
437             params.type_name(),
481                 serialize_externally_tagged_variant(params, variant, variant_index, cattrs)
484                 serialize_internally_tagged_variant(params, variant, cattrs, tag)
488                     params,
497                 serialize_untagged_variant(params, variant, cattrs)
508     params: &Parameters,
517         let ser = wrap_serialize_variant_with(params, path, variant);
544                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
565             params,
573             params,
581     params: &Parameters,
589     let enum_ident_str = params.type_name();
593         let ser = wrap_serialize_variant_with(params, path, variant);
620                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
638             params,
647     params: &Parameters,
654     let this_type = &params.this_type;
666         let ser = wrap_serialize_variant_with(params, path, variant);
685                     field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
701                 serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields)
705                 params,
728     let (_, ty_generics, where_clause) = params.generics.split_for_impl();
731         params.generics.clone()
733         bound::with_lifetime_bound(&params.generics, "'__a")
770     params: &Parameters,
775         let ser = wrap_serialize_variant_with(params, path, variant);
791                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
800         Style::Tuple => serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields),
803             serialize_struct_variant(StructVariant::Untagged, params, &variant.fields, type_name)
819     params: &Parameters,
827     let serialize_stmts = serialize_tuple_struct_visitor(fields, params, true, &tuple_trait);
890     params: &Parameters,
895         return serialize_struct_variant_with_flatten(context, params, fields, name);
905     let serialize_fields = serialize_struct_visitor(fields, params, true, &struct_trait);
974     params: &Parameters,
979     let serialize_fields = serialize_struct_visitor(fields, params, true, &struct_trait);
993             let this_type = &params.this_type;
997             let (_, ty_generics, where_clause) = params.generics.split_for_impl();
998             let wrapper_generics = bound::with_lifetime_bound(&params.generics, "'__a");
1061     params: &Parameters,
1075                     params,
1090                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
1109     params: &Parameters,
1122                 get_member(params, field, member)
1133                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
1174     params: &Parameters,
1179     wrap_serialize_with(params, serialize_with, &[field_ty], &[quote!(#field_expr)])
1183     params: &Parameters,
1202         params,
1210     params: &Parameters,
1215     let this_type = &params.this_type;
1216     let (_, ty_generics, where_clause) = params.generics.split_for_impl();
1219         params.generics.clone()
1221         bound::with_lifetime_bound(&params.generics, "'__a")
1269 fn get_member(params: &Parameters, field: &Field, member: &Member) -> TokenStream {
1270     let self_var = &params.self_var;
1271     match (params.is_remote, field.attrs.getter()) {
1273             if params.is_packed {
1280             let inner = if params.is_packed {