You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: macro.invocation.rs
    path of file: ./repos/jinx-rust/tests/samples/macro
    
    the code of the file until where you have to start completion: 
declare_clippy_lint! {
    /// ### q
    /// ```rust
    /// let b: Vec<&str> = vec![];
    /// if !b.is_empty() {
    ///     panic!(q: {:?}", b);
    /// }
    /// ```
    /// Use instead:
    /// ```rust
    /// let b: Vec<&str> = vec![];
    /// assert!(b.is_empty(), "there are sad people: {:?}", b);
    /// ```
    #[clippy::version = "1.57.0"]
    pub MANUAL_ASSERT,
    pedantic,
    "`panic!` and only a `panic!` in `if`-then statement"
}


fn aux<Xs: HList, Ys: HList>(xs: Xs, ys: Ys) -> Expr!(Xs + Ys) where
Xs: Add<Ys> {
    xs + ys
}

declare_lint_pass!(Attributes => [
    INLINE_ALWAYS,
    DEPRECATED_SEMVER,
    USELESS_ATTRIBUTE,
    BLANKET_CLIPPY_RESTRICTION_LINTS,
]);

fn main() {
    let xs: HList!(&str, bool, Vec<u64>) = hlist!("foo", false, vec![]);
    let ys: HList!(u64, [u8; 3], ()) = hlist!(0, [0, 1, 2], ());
    let zs: Expr!((HList![&str] + HList![bool] + HList![Vec<u64>]) + (HList![u64] + HList![[u8; 3], ()]) + HList![]) = aux(xs, ys);
    higher_order!(subst ($x:expr, $y:expr, $foo:expr) => (($x + $y, $foo)));
    assert_eq!(zs, hlist!["foo", false, vec![], 0, [0, 1, 2], ()]);
	quote!(fn $name() -> bool { true });
    impl_lint_pass!(Arithmetic => [INTEGER_ARITHMETIC, FLOAT_ARITHMETIC]);
	let result = quote! {
        macro_rules! generated_foo {
            (1 $$x:expr $$($$y:tt,)* $$(= $$z:tt)*) => {};
        }
    };
    if !matches!(
        macro_name.as_str(),
        "assert_eq" | "debug_assert_eq" | "assert_ne" | "debug_assert_ne"
    ) {}
    if matches!(cx.tcx.type_of(id).kind(), ty::Adt(adt, _) if ty_adt.did() == adt.did()) {}
    if !matches!(
        get_expr_use_or_unification_node(tcx, expr),
        None | Some((
            Node::Stmt(Stmt {
                kind: StmtKind::Expr(_)
                    | StmtKind::Semi(_)
                    | StmtKind::Local(Local {
                        pat: Pat {
                            kind: PatKind::Wild,
                            ..
                        },
                        ..
                    }),
                ..
            }),
            _
        ))
    ) {}
    if_chain! {
        if let ExprKind::If(cond, then, None) = expr.kind;
        if !matches!(cond.kind, ExprKind::Let(_));
        if !expr.span.from_expansion();
        let then = peel_blocks_with_stmt(then);
        if let Some(macro_call) = root_macro_call(then.span);
        if cx.tcx.item_name(macro_call.def_id) == sym::panic;
        if !cx.tcx.sess.source_map().is_multiline(cond.span);
        if let Some(format_args) = FormatArgsExpn::find_nested(cx, then, macro_call.expn);
        then {
            let mut applicability = Applicability::MachineApplicable;
            let format_args_snip = snippet_with_applicability(cx, format_args.inputs_span(), "..", &mut applicability);
            let cond = cond.peel_drop_temps();
            let (cond, not) = match cond.kind {
                ExprKind::Unary(UnOp::Not, e) => (e, ""),
                _ => (cond, "!"),
            };
            let cond_sugg = sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par();
            let sugg = format!("assert!({not}{cond_sugg}, {format_args_snip});");
            span_lint_and_sugg(
                cx,
                MANUAL_ASSERT,
                expr.span,
                "only a `panic!` in `if`-then statement",
                "try",
                sugg,
                Applicability::MachineApplicable,
            );
        }
    }
    if_chain! {
        if meets_msrv(msrv.as_ref(), &msrvs::TOOL_ATTRIBUTES);
        // check cfg_attr
        if attr.has_name(sym::cfg_attr);
        if let Some(items) = attr.meta_item_list();
        if items.len() == 2;
        // check for `rustfmt`
        if let Some(feature_item) = items[0].meta_item();
        if feature_item.has_name(sym::rustfmt);
        // check for `rustfmt_skip` and `rustfmt::skip`
        if let Some(skip_item) = &items[1].meta_item();
        if skip_item.has_name(sym!(rustfmt_skip)) ||
            skip_item.path.segments.last().expect("empty path in attribute").ident.name == sym::skip;
        // Only lint outer attributes, because custom inner attributes are unstable
        // Tracking issue: https://github.com/rust-lang/rust/issues/54726
        if attr.style == AttrStyle::Outer;
        then {
            span_lint_and_sugg(
                cx,
                DEPRECATED_CFG_ATTR,
                attr.span,
                "`cfg_attr` is deprecated for rustfmt and got replaced by tool attributes",
                "use",
                "#[rustfmt::skip]".to_string(),
                Applicability::MachineApplicable,
            );
        }
    }
    if_chain! {
        if let ExprKind::Binary(ref op, left, right) = &expr.kind;
        if let Some((candidate, check)) = norm
    
fn main() {
    let xs: HList!(&str, bool, Vec<u64>) = hlist!("foo", false, vec![]);
    let ys: HList!(u64, [u8; 3], ()) = hlist!(0, [0, 1, 2], ());
    let zs: Expr!((HList![&str] + HList![bool] + HList![Vec<u64>]) + (HList![u64] + HList![[u8; 3], ()]) + HList![]) = aux(xs, ys);
    higher_order!(subst ($x:expr, $y:expr, $foo:expr) => (($x + $y, $foo)));
    assert_eq!(zs, hlist!["foo", false, vec![], 0, [0, 1, 2], ()]);
	quote!(fn $name() -> bool { true });
    impl_lint_pass!(Arithmetic => [INTEGER_ARITHMETIC, FLOAT_ARITHMETIC]);
	let result = quote! {
        macro_rules! generated_foo {
            (1 $$x:expr $$($$y:tt,)* $$(= $$z:tt)*) => {};
        }
    };
    if !matches!(
        macro_name.as_str(),
        "assert_eq" | "debug_assert_eq" | "assert_ne" | "debug_assert_ne"
    ) {}
    if matches!(cx.tcx.type_of(id).kind(), ty::Adt(adt, _) if ty_adt.did() == adt.did()) {}
    if !matches!(
        get_expr_use_or_unification_node(tcx, expr),
        None | Some((
            Node::Stmt(Stmt {
                kind: StmtKind::Expr(_)
                    | StmtKind::Semi(_)
                    | StmtKind::Local(Local {
                        pat: Pat {
                            kind: PatKind::Wild,
                            ..
                        },
                        ..
                    }),
                ..
            }),
            _
        ))
    ) {}
    if_chain! {
        if let ExprKind::If(cond, then, None) = expr.kind;
        if !matches!(cond.kind, ExprKind::Let(_));
        if !expr.span.from_expansion();
        let then = peel_blocks_with_stmt(then);
        if let Some(macro_call) = root_macro_call(then.span);
        if cx.tcx.item_name(macro_call.def_id) == sym::panic;
        if !cx.tcx.sess.source_map().is_multiline(cond.span);
        if let Some(format_args) = FormatArgsExpn::find_nested(cx, then, macro_call.expn);
        then {
            let mut applicability = Applicability::MachineApplicable;
            let format_args_snip = snippet_with_applicability(cx, format_args.inputs_span(), "..", &mut applicability);
            let cond = cond.peel_drop_temps();
            let (cond, not) = match cond.kind {
                ExprKind::Unary(UnOp::Not, e) => (e, ""),
                _ => (cond, "!"),
            };
            let cond_sugg = sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par();
            let sugg = format!("assert!({not}{cond_sugg}, {format_args_snip});");
            span_lint_and_sugg(
                cx,
                MANUAL_ASSERT,
                expr.span,
                "only a `panic!` in `if`-then statement",
                "try",
                sugg,
                Applicability::MachineApplicable,
            );
        }
    }
    if_chain! {
        if meets_msrv(msrv.as_ref(), &msrvs::TOOL_ATTRIBUTES);
        // check cfg_attr
        if attr.has_name(sym::cfg_attr);
        if let Some(items) = attr.meta_item_list();
        if items.len() == 2;
        // check for `rustfmt`
        if let Some(feature_item) = items[0].meta_item();
        if feature_item.has_name(sym::rustfmt);
        // check for `rustfmt_skip` and `rustfmt::skip`
        if let Some(skip_item) = &items[1].meta_item();
        if skip_item.has_name(sym!(rustfmt_skip)) ||
            skip_item.path.segments.last().expect("empty path in attribute").ident.name == sym::skip;
        // Only lint outer attributes, because custom inner attributes are unstable
        // Tracking issue: https://github.com/rust-lang/rust/issues/54726
        if attr.style == AttrStyle::Outer;
        then {
            span_lint_and_sugg(
                cx,
                DEPRECATED_CFG_ATTR,
                attr.span,
                "`cfg_attr` is deprecated for rustfmt and got replaced by tool attributes",
                "use",
                "#[rustfmt::skip]".to_string(),
                Applicability::MachineApplicable,
            );
        }
    }
    if_chain! {
        if let ExprKind::Binary(ref op, left, right) = &expr.kind;
        if let Some((candidate, check)) = normalize_le_ge(op, left, right);
        if let Some((from, to)) = get_types_from_cast(check, INTS, "max_value", "MAX");

        then {
            Conversion::try_new(candidate, from, to)
        } else {
            None
        }
    }
    let help = format!(
        "because `{}` is the {} value for this type, {}",
        snippet(cx, culprit.expr.span, "x"),
        match culprit.which {
            ExtremeType::Minimum => "minimum",
            ExtremeType::Maximum => "maximum",
        },
        conclusion
    );
   
    let msg = format!(
        "this `{}` can be collapsed into the outer `{}`",
        if matches!(inner, IfLetOrMatch::Match(..)) { "match" } else { "if let" },
        if outer_is_match { "match" } else { "if let" },
    );
    let mut contents = format!(
        indoc! {"
            #![warn(clippy::{})]

            fn main() {{
                // test code goes here
            }}
        "},
        lint_name
    );
    format!(
        "store.register_{lint_pass}_pass(move || Box::new({module_name}::{camel_name}::new(msrv)));\n    ",
        lint_pass = lint.pass,
        module_name = lint.name,
        camel_name = to_camel_case(lint.name),
    );
    format!(
        indoc! {r#"
            # {}

            [package]
            name = "{}"
            version = "0.1.0"
            publish = false

            [workspace]
        "#},
        hint, lint_name
    );
    match iter.next() {
        // #[clippy::version = "version"] pub
        Some((TokenKind::Pound, _)) => {
            match_tokens!(iter, OpenBracket Ident Colon Colon Ident Eq Literal{..} CloseBracket Ident);
        },
        // pub
        Some((TokenKind::Ident, _)) => (),
        _ => continue,
    }
    let (name, group, desc) = match_tokens!(
        iter,
        // LINT_NAME
        Ident(name) Comma
        // group,
        Ident(group) Comma
        // "description" }
        Literal{..}(desc) CloseBrace
        // #[clippy::version = "version"]
        Pound OpenBracket Ident Colon Colon Ident Eq Literal{..} CloseBracket
        // pub LINT_NAME,
        Ident Ident(name) Comma
        // "description"
        Literal{kind: LiteralKind::Str{..},..}(reason)
        // ("old_name",
        Whitespace OpenParen Literal{kind: LiteralKind::Str{..},..}(old_name) Comma
        // "new_name"),
        Whitespace Literal{kind: LiteralKind::Str{..},..}(new_name) CloseParen Comma
    );
    
    info!(//debug
        "{}: sending function_code={:04x} data={:04x} crc=0x{:04X} data={:02X?}",
        self.name, function_code, data, crc, output_cmd
    );
}