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: graphql_vars.rs
    path of file: ./repos/juniper/juniper/src/macros
    
    the code of the file until where you have to start completion: //! [`graphql_vars!`] macro implementation.
//!
//! [`graphql_vars!`]: graphql_vars

/// Constructs [`Variables`] via JSON-like syntax.
///
/// [`Variables`] key should implement [`Into`]`<`[`String`]`>`.
/// ```rust
/// # use std::borrow::Cow;
/// #
/// # use juniper::{graphql_vars, Variables};
/// #
/// let code = 200;
/// let features = vec!["key", "value"];
/// let key: Cow<'static, str> = "key".into();
///
/// let value: Variables = graphql_vars! {
///     "code": code,
///     "success": code == 200,
///     features[0]: features[1],
///     key: @var,
/// };
/// ```
///
/// See [`graphql_input_value!`] for more info on syntax of value after `:`.
///
/// [`graphql_input_value!`]: crate::graphql_input_value
/// [`Variables`]: crate::Variables
#[macro_export]
macro_rules! graphql_vars {
    ////////////
    // Object //
    ////////////

    // Done.
    (@object $object:ident () () ()) => {};

    // Insert the current entry followed by trailing comma.
    (@object $object:ident [$($key:tt)+] ($value:expr) , $($rest:tt)*) => {
        let _ = $object.insert(($($key)+).into(), $value);
        $crate::graphql_vars! {@object $object () ($($rest)*) ($($rest)*)};
    };

    // Current entry followed by unexpected token.
    (@object $object:ident [$($key:tt)+] ($value:expr) $unexpected:tt $($rest:tt)*) => {
        $crate::graphql_vars! {@unexpected $unexpected};
    };

    // Insert the last entry without trailing comma.
    (@object $object:ident [$($key:tt)+] ($value:expr)) => {
        let _ = $object.insert(($($key)+).into(), $value);
    };

    // Next value is `null`.
    (@object $object:ident ($($key:tt)+) (: null $($rest:tt)*) $copy:tt) => {
        $crate::graphql_vars! {
            @object $object
            [$($key)+]
            ($crate::graphql_input_value!(null)) $($rest)*
        };
    };

    // Next value is `None`.
    (@object $object:ident ($($key:tt)+) (: None $($rest:tt)*) $copy:tt) => {
        $crate::graphql_vars! {
            @object $object
            [$($key)+]
            ($crate::graphql_input_value!(None)) $($rest)*
        };
    };

    // Next value is a variable.
    (@object $object:ident ($($key:tt)+) (: @$var:ident $($rest:tt)*) $copy:tt) => {
        $crate::graphql_vars! {
            @object $object
            [$($key)+]
            ($crate::graphql_input_value!(@$var)) $($rest)*
        };
    };

    // Next value is an array.
    (@object $object:ident ($($key:tt)+) (: [$($array:tt)*] $($rest:tt)*) $copy:tt) => {
        $crate::graphql_vars! {
            @object $object
            [$($key)+]
            ($crate::graphql_input_value!([$($array)*])) $($rest)*
        };
    };

    // Next value is a map.
    (@object $object:ident ($($key:tt)+) (: {$($map:tt)*} $($rest:tt)*) $copy:tt) => {
        $crate::graphql_vars! {
            @object $object
            [$($key)+]
            ($crate::graphql_input_value!({$($map)*})) $($rest)*
        };
    };

    // Next
    
    fn list() {
        let val = 42;

        assert_eq!(
            graphql_vars! {"key": []},
            vec![("key".into(), IV::list(vec![]))]
                .into_iter()
                .collect::<V>(),
        );

        assert_eq!(
            graphql_vars! {"key": [null]},
            vec![("key".into(), IV::list(vec![IV::Null]))]
                .into_iter()
                .collect::<V>(),
        );

        assert_eq!(
            graphql_vars! {"key": [1]},
            vec![("key".into(), IV::list(vec![IV::scalar(1)]))]
                .into_iter()
                .collect::<V>(),
        );
        assert_eq!(
            graphql_vars! {"key": [1 + 2]},
            vec![("key".into(), IV::list(vec![IV::scalar(3)]))]
                .into_iter()
                .collect::<V>(),
        );
        assert_eq!(
            graphql_vars! {"key": [(val)]},
            vec![("key".into(), IV::list(vec![IV::scalar(42)]))]
                .into_iter()
                .collect::<V>(),
        );

        assert_eq!(
            graphql_vars! {"key": [ENUM]},
            vec![("key".into(), IV::list(vec![IV::enum_value("ENUM")]))]
                .into_iter()
                .collect::<V>(),
        );
        assert_eq!(
            graphql_vars! {"key": [lowercase]},
            vec![("key".into(), IV::list(vec![IV::enum_value("lowercase")]))]
                .into_iter()
                .collect::<V>(),
        );

        assert_eq!(
            graphql_vars! {"key": [@var]},
            vec![("key".into(), IV::list(vec![IV::variable("var")]))]
                .into_iter()
                .collect::<V>(),
        );
        assert_eq!(
            graphql_vars! {"key": [@array]},
            vec![("key".into(), IV::list(vec![IV::variable("array")]))]
                .into_iter()
                .collect::<V>(),
        );
        assert_eq!(
            graphql_vars! {"key": [@object]},
            vec![("key".into(), IV::list(vec![IV::variable("object")]))]
                .into_iter()
                .collect::<V>(),
        );

        assert_eq!(
            graphql_vars! {"key": [1, [2], 3]},
            vec![(
                "key".into(),
                IV::list(vec![
                    IV::scalar(1),
                    IV::list(vec![IV::scalar(2)]),
                    IV::scalar(3),
                ]),
            )]
            .into_iter()
            .collect::<V>(),
        );
        assert_eq!(
            graphql_vars! {"key": [1, [2 + 3], 3]},
            vec![(
                "key".into(),
                IV::list(vec![
                    IV::scalar(1),
                    IV::list(vec![IV::scalar(5)]),
                    IV::scalar(3),
                ]),
            )]
            .into_iter()
            .collect::<V>(),
        );
        assert_eq!(
            graphql_vars! {"key": [1, [ENUM], (val)]},
            vec![(
                "key".into(),
                IV::list(vec![
                    IV::scalar(1),
                    IV::list(vec![IV::enum_value("ENUM")]),
                    IV::scalar(42),
                ]),
            )]
            .into_iter()
            .collect::<V>(),
        );
        assert_eq!(
            graphql_vars! {"key": [1 + 2, [(val)], @val]},
            vec![(
                "key".into(),
                IV::list(vec![
                    IV::scalar(3),
                    IV::list(vec![IV::scalar(42)]),
                    IV::variable("val"),
                ]),
            )]
            .into_iter()
            .collect::<V>(),
        );
        assert_eq!(
            graphql_vars! {"key": [1, [@val], ENUM]},
            vec![(
                "key".into(),
                IV::list(vec![
                    IV::scalar(1),
                    IV::list(vec![IV::variable("val")]),
                    IV::enum_value("ENUM"),
                ]),
            )]
            .into_iter()
            .collect::<V>(),
        );
    }