1 use serde::{Deserialize, Serialize}; 2 trait AssociatedType { 3 type X; 4 } 5 impl AssociatedType for i32 { 6 type X = i32; 7 } 8 struct DefaultTyParam<T: AssociatedType<X = i32> = i32> { 9 phantom: PhantomData<T>, 10 } 11 #[doc(hidden)] 12 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] 13 const _: () = { 14 #[allow(unused_extern_crates, clippy::useless_attribute)] 15 extern crate serde as _serde; 16 #[automatically_derived] 17 impl<T: AssociatedType<X = i32>> _serde::Serialize for DefaultTyParam<T> { serialize<__S>( &self, __serializer: __S, ) -> _serde::__private::Result<__S::Ok, __S::Error> where __S: _serde::Serializer,18 fn serialize<__S>( 19 &self, 20 __serializer: __S, 21 ) -> _serde::__private::Result<__S::Ok, __S::Error> 22 where 23 __S: _serde::Serializer, 24 { 25 let mut __serde_state = match _serde::Serializer::serialize_struct( 26 __serializer, 27 "DefaultTyParam", 28 false as usize + 1, 29 ) { 30 _serde::__private::Ok(__val) => __val, 31 _serde::__private::Err(__err) => { 32 return _serde::__private::Err(__err); 33 } 34 }; 35 match _serde::ser::SerializeStruct::serialize_field( 36 &mut __serde_state, 37 "phantom", 38 &self.phantom, 39 ) { 40 _serde::__private::Ok(__val) => __val, 41 _serde::__private::Err(__err) => { 42 return _serde::__private::Err(__err); 43 } 44 }; 45 _serde::ser::SerializeStruct::end(__serde_state) 46 } 47 } 48 }; 49 #[doc(hidden)] 50 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] 51 const _: () = { 52 #[allow(unused_extern_crates, clippy::useless_attribute)] 53 extern crate serde as _serde; 54 #[automatically_derived] 55 impl<'de, T: AssociatedType<X = i32>> _serde::Deserialize<'de> for DefaultTyParam<T> { deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error> where __D: _serde::Deserializer<'de>,56 fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error> 57 where 58 __D: _serde::Deserializer<'de>, 59 { 60 #[allow(non_camel_case_types)] 61 enum __Field { 62 __field0, 63 __ignore, 64 } 65 struct __FieldVisitor; 66 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { 67 type Value = __Field; 68 fn expecting( 69 &self, 70 __formatter: &mut _serde::__private::Formatter, 71 ) -> _serde::__private::fmt::Result { 72 _serde::__private::Formatter::write_str(__formatter, "field identifier") 73 } 74 fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E> 75 where 76 __E: _serde::de::Error, 77 { 78 match __value { 79 0u64 => _serde::__private::Ok(__Field::__field0), 80 _ => _serde::__private::Ok(__Field::__ignore), 81 } 82 } 83 fn visit_str<__E>( 84 self, 85 __value: &str, 86 ) -> _serde::__private::Result<Self::Value, __E> 87 where 88 __E: _serde::de::Error, 89 { 90 match __value { 91 "phantom" => _serde::__private::Ok(__Field::__field0), 92 _ => _serde::__private::Ok(__Field::__ignore), 93 } 94 } 95 fn visit_bytes<__E>( 96 self, 97 __value: &[u8], 98 ) -> _serde::__private::Result<Self::Value, __E> 99 where 100 __E: _serde::de::Error, 101 { 102 match __value { 103 b"phantom" => _serde::__private::Ok(__Field::__field0), 104 _ => _serde::__private::Ok(__Field::__ignore), 105 } 106 } 107 } 108 impl<'de> _serde::Deserialize<'de> for __Field { 109 #[inline] 110 fn deserialize<__D>( 111 __deserializer: __D, 112 ) -> _serde::__private::Result<Self, __D::Error> 113 where 114 __D: _serde::Deserializer<'de>, 115 { 116 _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) 117 } 118 } 119 struct __Visitor<'de, T: AssociatedType<X = i32>> { 120 marker: _serde::__private::PhantomData<DefaultTyParam<T>>, 121 lifetime: _serde::__private::PhantomData<&'de ()>, 122 } 123 impl<'de, T: AssociatedType<X = i32>> _serde::de::Visitor<'de> for __Visitor<'de, T> { 124 type Value = DefaultTyParam<T>; 125 fn expecting( 126 &self, 127 __formatter: &mut _serde::__private::Formatter, 128 ) -> _serde::__private::fmt::Result { 129 _serde::__private::Formatter::write_str(__formatter, "struct DefaultTyParam") 130 } 131 #[inline] 132 fn visit_seq<__A>( 133 self, 134 mut __seq: __A, 135 ) -> _serde::__private::Result<Self::Value, __A::Error> 136 where 137 __A: _serde::de::SeqAccess<'de>, 138 { 139 let __field0 = match match _serde::de::SeqAccess::next_element::<PhantomData<T>>( 140 &mut __seq, 141 ) { 142 _serde::__private::Ok(__val) => __val, 143 _serde::__private::Err(__err) => { 144 return _serde::__private::Err(__err); 145 } 146 } { 147 _serde::__private::Some(__value) => __value, 148 _serde::__private::None => { 149 return _serde::__private::Err(_serde::de::Error::invalid_length( 150 0usize, 151 &"struct DefaultTyParam with 1 element", 152 )); 153 } 154 }; 155 _serde::__private::Ok(DefaultTyParam { phantom: __field0 }) 156 } 157 #[inline] 158 fn visit_map<__A>( 159 self, 160 mut __map: __A, 161 ) -> _serde::__private::Result<Self::Value, __A::Error> 162 where 163 __A: _serde::de::MapAccess<'de>, 164 { 165 let mut __field0: _serde::__private::Option<PhantomData<T>> = 166 _serde::__private::None; 167 while let _serde::__private::Some(__key) = 168 match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { 169 _serde::__private::Ok(__val) => __val, 170 _serde::__private::Err(__err) => { 171 return _serde::__private::Err(__err); 172 } 173 } 174 { 175 match __key { 176 __Field::__field0 => { 177 if _serde::__private::Option::is_some(&__field0) { 178 return _serde::__private::Err( 179 <__A::Error as _serde::de::Error>::duplicate_field( 180 "phantom", 181 ), 182 ); 183 } 184 __field0 = _serde::__private::Some( 185 match _serde::de::MapAccess::next_value::<PhantomData<T>>( 186 &mut __map, 187 ) { 188 _serde::__private::Ok(__val) => __val, 189 _serde::__private::Err(__err) => { 190 return _serde::__private::Err(__err); 191 } 192 }, 193 ); 194 } 195 _ => { 196 let _ = match _serde::de::MapAccess::next_value::< 197 _serde::de::IgnoredAny, 198 >(&mut __map) 199 { 200 _serde::__private::Ok(__val) => __val, 201 _serde::__private::Err(__err) => { 202 return _serde::__private::Err(__err); 203 } 204 }; 205 } 206 } 207 } 208 let __field0 = match __field0 { 209 _serde::__private::Some(__field0) => __field0, 210 _serde::__private::None => { 211 match _serde::__private::de::missing_field("phantom") { 212 _serde::__private::Ok(__val) => __val, 213 _serde::__private::Err(__err) => { 214 return _serde::__private::Err(__err); 215 } 216 } 217 } 218 }; 219 _serde::__private::Ok(DefaultTyParam { phantom: __field0 }) 220 } 221 } 222 const FIELDS: &'static [&'static str] = &["phantom"]; 223 _serde::Deserializer::deserialize_struct( 224 __deserializer, 225 "DefaultTyParam", 226 FIELDS, 227 __Visitor { 228 marker: _serde::__private::PhantomData::<DefaultTyParam<T>>, 229 lifetime: _serde::__private::PhantomData, 230 }, 231 ) 232 } deserialize_in_place<__D>( __deserializer: __D, __place: &mut Self, ) -> _serde::__private::Result<(), __D::Error> where __D: _serde::Deserializer<'de>,233 fn deserialize_in_place<__D>( 234 __deserializer: __D, 235 __place: &mut Self, 236 ) -> _serde::__private::Result<(), __D::Error> 237 where 238 __D: _serde::Deserializer<'de>, 239 { 240 #[allow(non_camel_case_types)] 241 enum __Field { 242 __field0, 243 __ignore, 244 } 245 struct __FieldVisitor; 246 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { 247 type Value = __Field; 248 fn expecting( 249 &self, 250 __formatter: &mut _serde::__private::Formatter, 251 ) -> _serde::__private::fmt::Result { 252 _serde::__private::Formatter::write_str(__formatter, "field identifier") 253 } 254 fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E> 255 where 256 __E: _serde::de::Error, 257 { 258 match __value { 259 0u64 => _serde::__private::Ok(__Field::__field0), 260 _ => _serde::__private::Ok(__Field::__ignore), 261 } 262 } 263 fn visit_str<__E>( 264 self, 265 __value: &str, 266 ) -> _serde::__private::Result<Self::Value, __E> 267 where 268 __E: _serde::de::Error, 269 { 270 match __value { 271 "phantom" => _serde::__private::Ok(__Field::__field0), 272 _ => _serde::__private::Ok(__Field::__ignore), 273 } 274 } 275 fn visit_bytes<__E>( 276 self, 277 __value: &[u8], 278 ) -> _serde::__private::Result<Self::Value, __E> 279 where 280 __E: _serde::de::Error, 281 { 282 match __value { 283 b"phantom" => _serde::__private::Ok(__Field::__field0), 284 _ => _serde::__private::Ok(__Field::__ignore), 285 } 286 } 287 } 288 impl<'de> _serde::Deserialize<'de> for __Field { 289 #[inline] 290 fn deserialize<__D>( 291 __deserializer: __D, 292 ) -> _serde::__private::Result<Self, __D::Error> 293 where 294 __D: _serde::Deserializer<'de>, 295 { 296 _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) 297 } 298 } 299 struct __Visitor<'de, 'place, T: AssociatedType<X = i32> + 'place> { 300 place: &'place mut DefaultTyParam<T>, 301 lifetime: _serde::__private::PhantomData<&'de ()>, 302 } 303 impl<'de, 'place, T: AssociatedType<X = i32> + 'place> _serde::de::Visitor<'de> 304 for __Visitor<'de, 'place, T> 305 { 306 type Value = (); 307 fn expecting( 308 &self, 309 __formatter: &mut _serde::__private::Formatter, 310 ) -> _serde::__private::fmt::Result { 311 _serde::__private::Formatter::write_str(__formatter, "struct DefaultTyParam") 312 } 313 #[inline] 314 fn visit_seq<__A>( 315 self, 316 mut __seq: __A, 317 ) -> _serde::__private::Result<Self::Value, __A::Error> 318 where 319 __A: _serde::de::SeqAccess<'de>, 320 { 321 if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed( 322 &mut __seq, 323 _serde::__private::de::InPlaceSeed(&mut self.place.phantom), 324 ) { 325 _serde::__private::Ok(__val) => __val, 326 _serde::__private::Err(__err) => { 327 return _serde::__private::Err(__err); 328 } 329 } { 330 return _serde::__private::Err(_serde::de::Error::invalid_length( 331 0usize, 332 &"struct DefaultTyParam with 1 element", 333 )); 334 } 335 _serde::__private::Ok(()) 336 } 337 #[inline] 338 fn visit_map<__A>( 339 self, 340 mut __map: __A, 341 ) -> _serde::__private::Result<Self::Value, __A::Error> 342 where 343 __A: _serde::de::MapAccess<'de>, 344 { 345 let mut __field0: bool = false; 346 while let _serde::__private::Some(__key) = 347 match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { 348 _serde::__private::Ok(__val) => __val, 349 _serde::__private::Err(__err) => { 350 return _serde::__private::Err(__err); 351 } 352 } 353 { 354 match __key { 355 __Field::__field0 => { 356 if __field0 { 357 return _serde::__private::Err( 358 <__A::Error as _serde::de::Error>::duplicate_field( 359 "phantom", 360 ), 361 ); 362 } 363 match _serde::de::MapAccess::next_value_seed( 364 &mut __map, 365 _serde::__private::de::InPlaceSeed(&mut self.place.phantom), 366 ) { 367 _serde::__private::Ok(__val) => __val, 368 _serde::__private::Err(__err) => { 369 return _serde::__private::Err(__err); 370 } 371 }; 372 __field0 = true; 373 } 374 _ => { 375 let _ = match _serde::de::MapAccess::next_value::< 376 _serde::de::IgnoredAny, 377 >(&mut __map) 378 { 379 _serde::__private::Ok(__val) => __val, 380 _serde::__private::Err(__err) => { 381 return _serde::__private::Err(__err); 382 } 383 }; 384 } 385 } 386 } 387 if !__field0 { 388 self.place.phantom = match _serde::__private::de::missing_field("phantom") { 389 _serde::__private::Ok(__val) => __val, 390 _serde::__private::Err(__err) => { 391 return _serde::__private::Err(__err); 392 } 393 }; 394 }; 395 _serde::__private::Ok(()) 396 } 397 } 398 const FIELDS: &'static [&'static str] = &["phantom"]; 399 _serde::Deserializer::deserialize_struct( 400 __deserializer, 401 "DefaultTyParam", 402 FIELDS, 403 __Visitor { 404 place: __place, 405 lifetime: _serde::__private::PhantomData, 406 }, 407 ) 408 } 409 } 410 }; 411