Lines Matching refs:input
334 fn from(input: DeriveInput) -> Item {
335 match input.data {
337 attrs: input.attrs,
338 vis: input.vis,
340 ident: input.ident,
341 generics: input.generics,
346 attrs: input.attrs,
347 vis: input.vis,
349 ident: input.ident,
350 generics: input.generics,
355 attrs: input.attrs,
356 vis: input.vis,
358 ident: input.ident,
359 generics: input.generics,
367 fn from(input: ItemStruct) -> DeriveInput {
369 attrs: input.attrs,
370 vis: input.vis,
371 ident: input.ident,
372 generics: input.generics,
374 struct_token: input.struct_token,
375 fields: input.fields,
376 semi_token: input.semi_token,
383 fn from(input: ItemEnum) -> DeriveInput {
385 attrs: input.attrs,
386 vis: input.vis,
387 ident: input.ident,
388 generics: input.generics,
390 enum_token: input.enum_token,
391 brace_token: input.brace_token,
392 variants: input.variants,
399 fn from(input: ItemUnion) -> DeriveInput {
401 attrs: input.attrs,
402 vis: input.vis,
403 ident: input.ident,
404 generics: input.generics,
406 union_token: input.union_token,
407 fields: input.fields,
903 fn parse(input: ParseStream) -> Result<Self> {
904 let begin = input.fork();
905 let attrs = input.call(Attribute::parse_outer)?;
906 parse_rest_of_item(begin, attrs, input)
913 input: ParseStream,
915 let ahead = input.fork();
920 let vis: Visibility = input.parse()?;
921 let sig: Signature = input.parse()?;
922 if input.peek(Token![;]) {
923 input.parse::<Token![;]>()?;
924 Ok(Item::Verbatim(verbatim::between(&begin, input)))
926 parse_rest_of_fn(input, Vec::new(), vis, sig).map(Item::Fn)
932 input.parse().map(Item::ExternCrate)
934 input.parse().map(Item::ForeignMod)
939 input.parse().map(Item::ForeignMod)
948 match parse_item_use(input, allow_crate_root_in_path)? {
950 None => Ok(Item::Verbatim(verbatim::between(&begin, input))),
953 let vis = input.parse()?;
954 let static_token = input.parse()?;
955 let mutability = input.parse()?;
956 let ident = input.parse()?;
957 if input.peek(Token![=]) {
958 input.parse::<Token![=]>()?;
959 input.parse::<Expr>()?;
960 input.parse::<Token![;]>()?;
961 Ok(Item::Verbatim(verbatim::between(&begin, input)))
963 let colon_token = input.parse()?;
964 let ty = input.parse()?;
965 if input.peek(Token![;]) {
966 input.parse::<Token![;]>()?;
967 Ok(Item::Verbatim(verbatim::between(&begin, input)))
977 eq_token: input.parse()?,
978 expr: input.parse()?,
979 semi_token: input.parse()?,
984 let vis = input.parse()?;
985 let const_token: Token![const] = input.parse()?;
986 let lookahead = input.lookahead1();
988 input.call(Ident::parse_any)?
992 let mut generics: Generics = input.parse()?;
993 let colon_token = input.parse()?;
994 let ty = input.parse()?;
995 let value = if let Some(eq_token) = input.parse::<Option<Token![=]>>()? {
996 let expr: Expr = input.parse()?;
1001 generics.where_clause = input.parse()?;
1002 let semi_token: Token![;] = input.parse()?;
1020 _ => Ok(Item::Verbatim(verbatim::between(&begin, input))),
1028 input.parse().map(Item::Trait)
1031 if let Some(item) = parse_impl(input, allow_verbatim_impl)? {
1034 Ok(Item::Verbatim(verbatim::between(&begin, input)))
1037 input.parse().map(Item::ForeignMod)
1039 input.parse().map(Item::Mod)
1044 input.parse().map(Item::Mod)
1046 parse_item_type(begin, input)
1048 input.parse().map(Item::Struct)
1050 input.parse().map(Item::Enum)
1052 input.parse().map(Item::Union)
1054 input.call(parse_trait_or_trait_alias)
1056 input.parse().map(Item::Trait)
1061 if let Some(item) = parse_impl(input, allow_verbatim_impl)? {
1064 Ok(Item::Verbatim(verbatim::between(&begin, input)))
1067 input.advance_to(&ahead);
1068 parse_macro2(begin, vis, input)
1076 input.parse().map(Item::Macro)
1114 input: ParseStream,
1118 let vis: Visibility = input.parse()?;
1120 TypeDefaultness::Optional => input.parse()?,
1123 let type_token: Token![type] = input.parse()?;
1124 let ident: Ident = input.parse()?;
1125 let mut generics: Generics = input.parse()?;
1126 let (colon_token, bounds) = Self::parse_optional_bounds(input)?;
1130 generics.where_clause = input.parse()?;
1135 let ty = Self::parse_optional_definition(input)?;
1141 generics.where_clause = input.parse()?;
1146 let semi_token: Token![;] = input.parse()?;
1162 input: ParseStream,
1164 let colon_token: Option<Token![:]> = input.parse()?;
1169 if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) {
1172 bounds.push_value(input.parse::<TypeParamBound>()?);
1173 if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) {
1176 bounds.push_punct(input.parse::<Token![+]>()?);
1183 fn parse_optional_definition(input: ParseStream) -> Result<Option<(Token![=], Type)>> {
1184 let eq_token: Option<Token![=]> = input.parse()?;
1186 let definition: Type = input.parse()?;
1196 fn parse(input: ParseStream) -> Result<Self> {
1197 let attrs = input.call(Attribute::parse_outer)?;
1198 let path = input.call(Path::parse_mod_style)?;
1199 let bang_token: Token![!] = input.parse()?;
1200 let ident: Option<Ident> = if input.peek(Token![try]) {
1201 input.call(Ident::parse_any).map(Some)
1203 input.parse()
1205 let (delimiter, tokens) = input.call(mac::parse_delimiter)?;
1207 Some(input.parse()?)
1225 fn parse_macro2(begin: ParseBuffer, _vis: Visibility, input: ParseStream) -> Result<Item> {
1226 input.parse::<Token![macro]>()?;
1227 input.parse::<Ident>()?;
1229 let mut lookahead = input.lookahead1();
1232 parenthesized!(paren_content in input);
1234 lookahead = input.lookahead1();
1239 braced!(brace_content in input);
1245 Ok(Item::Verbatim(verbatim::between(&begin, input)))
1250 fn parse(input: ParseStream) -> Result<Self> {
1252 attrs: input.call(Attribute::parse_outer)?,
1253 vis: input.parse()?,
1254 extern_token: input.parse()?,
1255 crate_token: input.parse()?,
1257 if input.peek(Token![self]) {
1258 input.call(Ident::parse_any)?
1260 input.parse()?
1264 if input.peek(Token![as]) {
1265 let as_token: Token![as] = input.parse()?;
1266 let rename: Ident = if input.peek(Token![_]) {
1267 Ident::from(input.parse::<Token![_]>()?)
1269 input.parse()?
1276 semi_token: input.parse()?,
1283 fn parse(input: ParseStream) -> Result<Self> {
1285 parse_item_use(input, allow_crate_root_in_path).map(Option::unwrap)
1290 input: ParseStream,
1293 let attrs = input.call(Attribute::parse_outer)?;
1294 let vis: Visibility = input.parse()?;
1295 let use_token: Token![use] = input.parse()?;
1296 let leading_colon: Option<Token![::]> = input.parse()?;
1297 let tree = parse_use_tree(input, allow_crate_root_in_path && leading_colon.is_none())?;
1298 let semi_token: Token![;] = input.parse()?;
1317 fn parse(input: ParseStream) -> Result<UseTree> {
1319 parse_use_tree(input, allow_crate_root_in_path).map(Option::unwrap)
1324 input: ParseStream,
1327 let lookahead = input.lookahead1();
1334 let ident = input.call(Ident::parse_any)?;
1335 if input.peek(Token![::]) {
1338 colon2_token: input.parse()?,
1339 tree: Box::new(input.parse()?),
1341 } else if input.peek(Token![as]) {
1344 as_token: input.parse()?,
1346 if input.peek(Ident) {
1347 input.parse()?
1348 } else if input.peek(Token![_]) {
1349 Ident::from(input.parse::<Token![_]>()?)
1351 return Err(input.error("expected identifier or underscore"));
1360 star_token: input.parse()?,
1364 let brace_token = braced!(content in input);
1399 fn parse(input: ParseStream) -> Result<Self> {
1401 attrs: input.call(Attribute::parse_outer)?,
1402 vis: input.parse()?,
1403 static_token: input.parse()?,
1404 mutability: input.parse()?,
1405 ident: input.parse()?,
1406 colon_token: input.parse()?,
1407 ty: input.parse()?,
1408 eq_token: input.parse()?,
1409 expr: input.parse()?,
1410 semi_token: input.parse()?,
1417 fn parse(input: ParseStream) -> Result<Self> {
1418 let attrs = input.call(Attribute::parse_outer)?;
1419 let vis: Visibility = input.parse()?;
1420 let const_token: Token![const] = input.parse()?;
1422 let lookahead = input.lookahead1();
1424 input.call(Ident::parse_any)?
1429 let colon_token: Token![:] = input.parse()?;
1430 let ty: Type = input.parse()?;
1431 let eq_token: Token![=] = input.parse()?;
1432 let expr: Expr = input.parse()?;
1433 let semi_token: Token![;] = input.parse()?;
1450 fn peek_signature(input: ParseStream) -> bool {
1451 let fork = input.fork();
1461 fn parse(input: ParseStream) -> Result<Self> {
1462 let constness: Option<Token![const]> = input.parse()?;
1463 let asyncness: Option<Token![async]> = input.parse()?;
1464 let unsafety: Option<Token![unsafe]> = input.parse()?;
1465 let abi: Option<Abi> = input.parse()?;
1466 let fn_token: Token![fn] = input.parse()?;
1467 let ident: Ident = input.parse()?;
1468 let mut generics: Generics = input.parse()?;
1471 let paren_token = parenthesized!(content in input);
1474 let output: ReturnType = input.parse()?;
1475 generics.where_clause = input.parse()?;
1495 fn parse(input: ParseStream) -> Result<Self> {
1496 let outer_attrs = input.call(Attribute::parse_outer)?;
1497 let vis: Visibility = input.parse()?;
1498 let sig: Signature = input.parse()?;
1499 parse_rest_of_fn(input, outer_attrs, vis, sig)
1504 input: ParseStream,
1510 let brace_token = braced!(content in input);
1524 fn parse(input: ParseStream) -> Result<Self> {
1526 let attrs = input.call(Attribute::parse_outer)?;
1527 match parse_fn_arg_or_variadic(input, attrs, allow_variadic)? {
1540 input: ParseStream,
1544 let ahead = input.fork();
1546 input.advance_to(&ahead);
1554 if input.peek(Ident) && input.peek2(Token![<]) {
1555 let span = input.fork().parse::<Ident>()?.span();
1563 ty: input.parse()?,
1567 let pat = Box::new(Pat::parse_single(input)?);
1568 let colon_token: Token![:] = input.parse()?;
1571 if let Some(dots) = input.parse::<Option<Token![...]>>()? {
1585 ty: input.parse()?,
1591 fn parse(input: ParseStream) -> Result<Self> {
1592 let reference = if input.peek(Token![&]) {
1593 let ampersand: Token![&] = input.parse()?;
1594 let lifetime: Option<Lifetime> = input.parse()?;
1599 let mutability: Option<Token![mut]> = input.parse()?;
1600 let self_token: Token![self] = input.parse()?;
1604 input.parse()?
1607 input.parse()?
1635 input: ParseStream,
1641 while !input.is_empty() {
1642 let attrs = input.call(Attribute::parse_outer)?;
1644 if let Some(dots) = input.parse::<Option<Token![...]>>()? {
1649 comma: if input.is_empty() {
1652 Some(input.parse()?)
1659 let arg = match parse_fn_arg_or_variadic(input, attrs, allow_variadic)? {
1663 comma: if input.is_empty() {
1666 Some(input.parse()?)
1692 if input.is_empty() {
1696 let comma: Token![,] = input.parse()?;
1705 fn parse(input: ParseStream) -> Result<Self> {
1706 let mut attrs = input.call(Attribute::parse_outer)?;
1707 let vis: Visibility = input.parse()?;
1708 let unsafety: Option<Token![unsafe]> = input.parse()?;
1709 let mod_token: Token![mod] = input.parse()?;
1710 let ident: Ident = if input.peek(Token![try]) {
1711 input.call(Ident::parse_any)
1713 input.parse()
1716 let lookahead = input.lookahead1();
1725 semi: Some(input.parse()?),
1729 let brace_token = braced!(content in input);
1754 fn parse(input: ParseStream) -> Result<Self> {
1755 let mut attrs = input.call(Attribute::parse_outer)?;
1756 let unsafety: Option<Token![unsafe]> = input.parse()?;
1757 let abi: Abi = input.parse()?;
1760 let brace_token = braced!(content in input);
1779 fn parse(input: ParseStream) -> Result<Self> {
1780 let begin = input.fork();
1781 let mut attrs = input.call(Attribute::parse_outer)?;
1782 let ahead = input.fork();
1787 let vis: Visibility = input.parse()?;
1788 let sig: Signature = input.parse()?;
1789 if input.peek(token::Brace) {
1791 braced!(content in input);
1795 Ok(ForeignItem::Verbatim(verbatim::between(&begin, input)))
1801 semi_token: input.parse()?,
1805 let vis = input.parse()?;
1806 let static_token = input.parse()?;
1807 let mutability = input.parse()?;
1808 let ident = input.parse()?;
1809 let colon_token = input.parse()?;
1810 let ty = input.parse()?;
1811 if input.peek(Token![=]) {
1812 input.parse::<Token![=]>()?;
1813 input.parse::<Expr>()?;
1814 input.parse::<Token![;]>()?;
1815 Ok(ForeignItem::Verbatim(verbatim::between(&begin, input)))
1825 semi_token: input.parse()?,
1829 parse_foreign_item_type(begin, input)
1837 input.parse().map(ForeignItem::Macro)
1858 fn parse(input: ParseStream) -> Result<Self> {
1859 let attrs = input.call(Attribute::parse_outer)?;
1860 let vis: Visibility = input.parse()?;
1861 let sig: Signature = input.parse()?;
1862 let semi_token: Token![;] = input.parse()?;
1874 fn parse(input: ParseStream) -> Result<Self> {
1876 attrs: input.call(Attribute::parse_outer)?,
1877 vis: input.parse()?,
1878 static_token: input.parse()?,
1879 mutability: input.parse()?,
1880 ident: input.parse()?,
1881 colon_token: input.parse()?,
1882 ty: input.parse()?,
1883 semi_token: input.parse()?,
1890 fn parse(input: ParseStream) -> Result<Self> {
1892 attrs: input.call(Attribute::parse_outer)?,
1893 vis: input.parse()?,
1894 type_token: input.parse()?,
1895 ident: input.parse()?,
1897 let mut generics: Generics = input.parse()?;
1898 generics.where_clause = input.parse()?;
1901 semi_token: input.parse()?,
1906 fn parse_foreign_item_type(begin: ParseBuffer, input: ParseStream) -> Result<ForeignItem> {
1918 input,
1924 Ok(ForeignItem::Verbatim(verbatim::between(&begin, input)))
1939 fn parse(input: ParseStream) -> Result<Self> {
1940 let attrs = input.call(Attribute::parse_outer)?;
1941 let mac: Macro = input.parse()?;
1945 Some(input.parse()?)
1957 fn parse(input: ParseStream) -> Result<Self> {
1959 attrs: input.call(Attribute::parse_outer)?,
1960 vis: input.parse()?,
1961 type_token: input.parse()?,
1962 ident: input.parse()?,
1964 let mut generics: Generics = input.parse()?;
1965 generics.where_clause = input.parse()?;
1968 eq_token: input.parse()?,
1969 ty: input.parse()?,
1970 semi_token: input.parse()?,
1975 fn parse_item_type(begin: ParseBuffer, input: ParseStream) -> Result<Item> {
1987 input,
1994 _ => return Ok(Item::Verbatim(verbatim::between(&begin, input))),
2011 fn parse(input: ParseStream) -> Result<Self> {
2012 let attrs = input.call(Attribute::parse_outer)?;
2013 let vis = input.parse::<Visibility>()?;
2014 let struct_token = input.parse::<Token![struct]>()?;
2015 let ident = input.parse::<Ident>()?;
2016 let generics = input.parse::<Generics>()?;
2017 let (where_clause, fields, semi_token) = derive::parsing::data_struct(input)?;
2035 fn parse(input: ParseStream) -> Result<Self> {
2036 let attrs = input.call(Attribute::parse_outer)?;
2037 let vis = input.parse::<Visibility>()?;
2038 let enum_token = input.parse::<Token![enum]>()?;
2039 let ident = input.parse::<Ident>()?;
2040 let generics = input.parse::<Generics>()?;
2041 let (where_clause, brace_token, variants) = derive::parsing::data_enum(input)?;
2059 fn parse(input: ParseStream) -> Result<Self> {
2060 let attrs = input.call(Attribute::parse_outer)?;
2061 let vis = input.parse::<Visibility>()?;
2062 let union_token = input.parse::<Token![union]>()?;
2063 let ident = input.parse::<Ident>()?;
2064 let generics = input.parse::<Generics>()?;
2065 let (where_clause, fields) = derive::parsing::data_union(input)?;
2080 fn parse_trait_or_trait_alias(input: ParseStream) -> Result<Item> {
2081 let (attrs, vis, trait_token, ident, generics) = parse_start_of_trait_alias(input)?;
2082 let lookahead = input.lookahead1();
2090 input,
2101 parse_rest_of_trait_alias(input, attrs, vis, trait_token, ident, generics)
2110 fn parse(input: ParseStream) -> Result<Self> {
2111 let outer_attrs = input.call(Attribute::parse_outer)?;
2112 let vis: Visibility = input.parse()?;
2113 let unsafety: Option<Token![unsafe]> = input.parse()?;
2114 let auto_token: Option<Token![auto]> = input.parse()?;
2115 let trait_token: Token![trait] = input.parse()?;
2116 let ident: Ident = input.parse()?;
2117 let generics: Generics = input.parse()?;
2119 input,
2132 input: ParseStream,
2141 let colon_token: Option<Token![:]> = input.parse()?;
2146 if input.peek(Token![where]) || input.peek(token::Brace) {
2149 supertraits.push_value(input.parse()?);
2150 if input.peek(Token![where]) || input.peek(token::Brace) {
2153 supertraits.push_punct(input.parse()?);
2157 generics.where_clause = input.parse()?;
2160 let brace_token = braced!(content in input);
2185 fn parse(input: ParseStream) -> Result<Self> {
2186 let (attrs, vis, trait_token, ident, generics) = parse_start_of_trait_alias(input)?;
2187 parse_rest_of_trait_alias(input, attrs, vis, trait_token, ident, generics)
2192 input: ParseStream,
2194 let attrs = input.call(Attribute::parse_outer)?;
2195 let vis: Visibility = input.parse()?;
2196 let trait_token: Token![trait] = input.parse()?;
2197 let ident: Ident = input.parse()?;
2198 let generics: Generics = input.parse()?;
2203 input: ParseStream,
2210 let eq_token: Token![=] = input.parse()?;
2214 if input.peek(Token![where]) || input.peek(Token![;]) {
2217 bounds.push_value(input.parse()?);
2218 if input.peek(Token![where]) || input.peek(Token![;]) {
2221 bounds.push_punct(input.parse()?);
2224 generics.where_clause = input.parse()?;
2225 let semi_token: Token![;] = input.parse()?;
2241 fn parse(input: ParseStream) -> Result<Self> {
2242 let begin = input.fork();
2243 let mut attrs = input.call(Attribute::parse_outer)?;
2244 let vis: Visibility = input.parse()?;
2245 let defaultness: Option<Token![default]> = input.parse()?;
2246 let ahead = input.fork();
2250 input.parse().map(TraitItem::Fn)
2255 input.advance_to(&ahead);
2256 let ident = input.call(Ident::parse_any)?;
2257 let mut generics: Generics = input.parse()?;
2258 let colon_token: Token![:] = input.parse()?;
2259 let ty: Type = input.parse()?;
2260 let default = if let Some(eq_token) = input.parse::<Option<Token![=]>>()? {
2261 let expr: Expr = input.parse()?;
2266 generics.where_clause = input.parse()?;
2267 let semi_token: Token![;] = input.parse()?;
2280 return Ok(TraitItem::Verbatim(verbatim::between(&begin, input)));
2287 input.parse().map(TraitItem::Fn)
2292 parse_trait_item_type(begin.fork(), input)
2301 input.parse().map(TraitItem::Macro)
2308 _ => return Ok(TraitItem::Verbatim(verbatim::between(&begin, input))),
2326 fn parse(input: ParseStream) -> Result<Self> {
2327 let attrs = input.call(Attribute::parse_outer)?;
2328 let const_token: Token![const] = input.parse()?;
2330 let lookahead = input.lookahead1();
2332 input.call(Ident::parse_any)?
2337 let colon_token: Token![:] = input.parse()?;
2338 let ty: Type = input.parse()?;
2339 let default = if input.peek(Token![=]) {
2340 let eq_token: Token![=] = input.parse()?;
2341 let default: Expr = input.parse()?;
2346 let semi_token: Token![;] = input.parse()?;
2363 fn parse(input: ParseStream) -> Result<Self> {
2364 let mut attrs = input.call(Attribute::parse_outer)?;
2365 let sig: Signature = input.parse()?;
2367 let lookahead = input.lookahead1();
2370 let brace_token = braced!(content in input);
2375 let semi_token: Token![;] = input.parse()?;
2392 fn parse(input: ParseStream) -> Result<Self> {
2393 let attrs = input.call(Attribute::parse_outer)?;
2394 let type_token: Token![type] = input.parse()?;
2395 let ident: Ident = input.parse()?;
2396 let mut generics: Generics = input.parse()?;
2397 let (colon_token, bounds) = FlexibleItemType::parse_optional_bounds(input)?;
2398 let default = FlexibleItemType::parse_optional_definition(input)?;
2399 generics.where_clause = input.parse()?;
2400 let semi_token: Token![;] = input.parse()?;
2414 fn parse_trait_item_type(begin: ParseBuffer, input: ParseStream) -> Result<TraitItem> {
2426 input,
2432 Ok(TraitItem::Verbatim(verbatim::between(&begin, input)))
2449 fn parse(input: ParseStream) -> Result<Self> {
2450 let attrs = input.call(Attribute::parse_outer)?;
2451 let mac: Macro = input.parse()?;
2455 Some(input.parse()?)
2467 fn parse(input: ParseStream) -> Result<Self> {
2469 parse_impl(input, allow_verbatim_impl).map(Option::unwrap)
2473 fn parse_impl(input: ParseStream, allow_verbatim_impl: bool) -> Result<Option<ItemImpl>> {
2474 let mut attrs = input.call(Attribute::parse_outer)?;
2475 let has_visibility = allow_verbatim_impl && input.parse::<Visibility>()?.is_some();
2476 let defaultness: Option<Token![default]> = input.parse()?;
2477 let unsafety: Option<Token![unsafe]> = input.parse()?;
2478 let impl_token: Token![impl] = input.parse()?;
2480 let has_generics = input.peek(Token![<])
2481 && (input.peek2(Token![>])
2482 || input.peek2(Token![#])
2483 || (input.peek2(Ident) || input.peek2(Lifetime))
2484 && (input.peek3(Token![:])
2485 || input.peek3(Token![,])
2486 || input.peek3(Token![>])
2487 || input.peek3(Token![=]))
2488 || input.peek2(Token![const]));
2490 input.parse()?
2496 && (input.peek(Token![const]) || input.peek(Token![?]) && input.peek2(Token![const]));
2498 input.parse::<Option<Token![?]>>()?;
2499 input.parse::<Token![const]>()?;
2502 let begin = input.fork();
2503 let polarity = if input.peek(Token![!]) && !input.peek2(token::Brace) {
2504 Some(input.parse::<Token![!]>()?)
2510 let first_ty_span = input.span();
2511 let mut first_ty: Type = input.parse()?;
2515 let is_impl_for = input.peek(Token![for]);
2517 let for_token: Token![for] = input.parse()?;
2539 self_ty = input.parse()?;
2545 Type::Verbatim(verbatim::between(&begin, input))
2549 generics.where_clause = input.parse()?;
2552 let brace_token = braced!(content in input);
2579 fn parse(input: ParseStream) -> Result<Self> {
2580 let begin = input.fork();
2581 let mut attrs = input.call(Attribute::parse_outer)?;
2582 let ahead = input.fork();
2596 if let Some(item) = parse_impl_item_fn(input, allow_omitted_body)? {
2599 Ok(ImplItem::Verbatim(verbatim::between(&begin, input)))
2602 input.advance_to(&ahead);
2603 let const_token: Token![const] = input.parse()?;
2604 let lookahead = input.lookahead1();
2606 input.call(Ident::parse_any)?
2610 let mut generics: Generics = input.parse()?;
2611 let colon_token: Token![:] = input.parse()?;
2612 let ty: Type = input.parse()?;
2613 let value = if let Some(eq_token) = input.parse::<Option<Token![=]>>()? {
2614 let expr: Expr = input.parse()?;
2619 generics.where_clause = input.parse()?;
2620 let semi_token: Token![;] = input.parse()?;
2639 _ => Ok(ImplItem::Verbatim(verbatim::between(&begin, input))),
2642 parse_impl_item_type(begin, input)
2651 input.parse().map(ImplItem::Macro)
2674 fn parse(input: ParseStream) -> Result<Self> {
2675 let attrs = input.call(Attribute::parse_outer)?;
2676 let vis: Visibility = input.parse()?;
2677 let defaultness: Option<Token![default]> = input.parse()?;
2678 let const_token: Token![const] = input.parse()?;
2680 let lookahead = input.lookahead1();
2682 input.call(Ident::parse_any)?
2687 let colon_token: Token![:] = input.parse()?;
2688 let ty: Type = input.parse()?;
2689 let eq_token: Token![=] = input.parse()?;
2690 let expr: Expr = input.parse()?;
2691 let semi_token: Token![;] = input.parse()?;
2711 fn parse(input: ParseStream) -> Result<Self> {
2713 parse_impl_item_fn(input, allow_omitted_body).map(Option::unwrap)
2718 input: ParseStream,
2721 let mut attrs = input.call(Attribute::parse_outer)?;
2722 let vis: Visibility = input.parse()?;
2723 let defaultness: Option<Token![default]> = input.parse()?;
2724 let sig: Signature = input.parse()?;
2729 if allow_omitted_body && input.parse::<Option<Token![;]>>()?.is_some() {
2734 let brace_token = braced!(content in input);
2752 fn parse(input: ParseStream) -> Result<Self> {
2753 let attrs = input.call(Attribute::parse_outer)?;
2754 let vis: Visibility = input.parse()?;
2755 let defaultness: Option<Token![default]> = input.parse()?;
2756 let type_token: Token![type] = input.parse()?;
2757 let ident: Ident = input.parse()?;
2758 let mut generics: Generics = input.parse()?;
2759 let eq_token: Token![=] = input.parse()?;
2760 let ty: Type = input.parse()?;
2761 generics.where_clause = input.parse()?;
2762 let semi_token: Token![;] = input.parse()?;
2777 fn parse_impl_item_type(begin: ParseBuffer, input: ParseStream) -> Result<ImplItem> {
2789 input,
2796 _ => return Ok(ImplItem::Verbatim(verbatim::between(&begin, input))),
2814 fn parse(input: ParseStream) -> Result<Self> {
2815 let attrs = input.call(Attribute::parse_outer)?;
2816 let mac: Macro = input.parse()?;
2820 Some(input.parse()?)
2850 fn parse(input: ParseStream) -> Result<Self> {
2851 let mut_token: Option<Token![mut]> = input.parse()?;