Function parse_impl

src/parse_impl.rs:229–294

(tokens: &mut TokenIter, attributes: Vec<Attribute>)

}

pub(crate) fn parse_impl(tokens: &mut TokenIter, attributes: Vec<Attribute>) -> Impl {
    let tk_unsafe = consume_ident(tokens, "unsafe");
    let tk_impl = parse_ident(tokens, "impl", "impl block");

    let impl_generic_params = consume_generic_params(tokens);
    let trait_or_self_ty = consume_stuff_until(
        tokens,
        |tk| match tk {
            TokenTree::Group(group) if group.delimiter() == Delimiter::Brace => true,
            TokenTree::Ident(ident) if ident == "for" || ident == "where" => true,
            _ => false,
        },
        true,
    );

    let (tk_for, trait_ty, self_ty) = if let Some(tk_for) = consume_ident(tokens, "for") {
        let self_ty = consume_stuff_until(
            tokens,
            |tk| match tk {
                TokenTree::Group(group) if group.delimiter() == Delimiter::Brace => true,
                TokenTree::Ident(ident) if ident == "where" => true,
                _ => false,
            },
            true,
        );

        (
            Some(tk_for),
            Some(TypeExpr {
                tokens: trait_or_self_ty,
            }),
            TypeExpr { tokens: self_ty },
        )
    } else {
        (
            None,
            None,
            TypeExpr {
                tokens: trait_or_self_ty,
            },
        )
    };

    let where_clause = consume_where_clause(tokens);

    let (tk_braces, inner_attributes, body_items) = match tokens.next().unwrap() {
        TokenTree::Group(group) if group.delimiter() == Delimiter::Brace => {
            parse_impl_body(group, false)
        }
        token => panic!("cannot parse impl: unexpected token {:?}", token),
    };

    Impl {
        attributes,
        tk_unsafe,
        tk_impl,
        impl_generic_params,
        trait_ty,