Method parse

src/ore-proc/src/static_list.rs:178–221

(input: syn::parse::ParseStream)

impl Parse for StaticListArgs {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        let mut ty: Option<LitStr> = None;
        let mut name: Option<LitStr> = None;
        let mut expected_count: Option<LitInt> = None;

        while !input.is_empty() {
            let lookahead = input.lookahead1();
            if lookahead.peek(keywords::ty) {
                let res = input.parse::<KeyValueArg<keywords::ty, LitStr>>()?;
                ty = Some(res.val);
            } else if lookahead.peek(keywords::name) {
                let res = input.parse::<KeyValueArg<keywords::name, LitStr>>()?;
                name = Some(res.val);
            } else if lookahead.peek(keywords::expected_count) {
                let res = input.parse::<KeyValueArg<keywords::expected_count, LitInt>>()?;
                expected_count = Some(res.val);
            } else if lookahead.peek(Token![,]) {
                let _ = input.parse::<Token![,]>()?;
            } else {
                return Err(input.error("Unexpected argument"));
            }
        }

        let mut missing_args = Vec::new();
        if ty.is_none() {
            missing_args.push("ty");
        }
        if name.is_none() {
            missing_args.push("name");
        }
        if expected_count.is_none() {
            missing_args.push("expected_count");
        }

        if !missing_args.is_empty() {
            input.error(format!("Missing arguments {:?}", missing_args));
        }

        Ok(StaticListArgs {
            ty: ty.expect("checked above"),
            name: name.expect("checked above"),
            expected_count: expected_count.expect("checked above"),
        })
    }
}

fn type_matches(static_ty: &Type, expected_ty: &LitStr) -> bool {