view rust/hg-core/src/copy_tracing/tests_support.rs @ 51864:1c5810ce737e default tip

typing: add `from __future__ import annotations` to remaining source files

Most of these look newer than when the original imports referenced in the
previous commit were dropped, so these weren't covered by the backout.  These
were found with:

    hg files mercurial hgext hgext3rd -I '**.py' -X '**/thirdparty' \
        | xargs grep -L 'from __future__ import annotations'

All of the `__init__.py` files that finds are empty, so those were ignored and
the rest manually edited.

//! Supporting macros for `tests.rs` in the same directory.
//! See comments there for usage.

/// Python-like set literal
macro_rules! set {
    (
        $Type: ty {
            $( $value: expr ),* $(,)?
        }
    ) => {{
        #[allow(unused_mut)]
        let mut set = <$Type>::new();
        $( set.insert($value); )*
        set
    }}
}

/// `{key => value}` map literal
macro_rules! map {
    (
        $Type: ty {
            $( $key: expr => $value: expr ),* $(,)?
        }
    ) => {{
        #[allow(unused_mut)]
        let mut set = <$Type>::new();
        $( set.insert($key, $value); )*
        set
    }}
}

macro_rules! copy_source {
    ($rev: expr, $path: expr, $overwritten: tt) => {
        CopySource {
            rev: $rev,
            path: $path,
            overwritten: set!(OrdSet<Revision> $overwritten),
        }
    };
}

macro_rules! compare_value {
    (
        $merge_revision: expr,
        $merge_case_for_dest: ident,
        ($min_rev: expr, $min_path: expr, $min_overwrite: tt),
        ($maj_rev: expr, $maj_path: expr, $maj_overwrite: tt) $(,)?
    ) => {
        compare_value(
            $merge_revision,
            || $merge_case_for_dest,
            &copy_source!($min_rev, $min_path, $min_overwrite),
            &copy_source!($maj_rev, $maj_path, $maj_overwrite),
        )
    };
}

macro_rules! tokenized_path_copies {
    (
        $path_map: ident, {$(
            $dest: expr => (
                $src_rev: expr,
                $src_path: expr,
                $src_overwrite: tt
            )
        ),*}
        $(,)*
    ) => {
        map!(InternalPathCopies {$(
            $path_map.tokenize(HgPath::new($dest)) =>
            copy_source!(
                $src_rev,
                Option::map($src_path, |p: &str| {
                    $path_map.tokenize(HgPath::new(p))
                }),
                $src_overwrite
            )
        )*})
    }
}

macro_rules! merge_case_callback {
    (
        $( $merge_path: expr => $merge_case: ident ),*
        $(,)?
    ) => {
        #[allow(unused)]
        |merge_path| -> MergeCase {
            $(
                if (merge_path == HgPath::new($merge_path)) {
                    return $merge_case
                }
            )*
            MergeCase::Normal
        }
    };
}

macro_rules! merge_copies_dict {
    (
        $current_merge: expr,
        $minor_copies: tt,
        $major_copies: tt,
        $get_merge_case: tt $(,)?
    ) => {
        {
            #[allow(unused_mut)]
            let mut map = TwoWayPathMap::default();
            let minor = tokenized_path_copies!(map, $minor_copies);
            let major = tokenized_path_copies!(map, $major_copies);
            merge_copies_dict(
                &map, $current_merge, minor, major,
                merge_case_callback! $get_merge_case,
            )
            .into_iter()
            .map(|(token, source)| {
                (
                    map.untokenize(token).to_string(),
                    (
                        source.rev,
                        source.path.map(|t| map.untokenize(t).to_string()),
                        source.overwritten.into_iter().collect(),
                    ),
                )
            })
            .collect::<OrdMap<
                String,
                (Revision, Option<String>, OrdSet<Revision>)
            >>()
        }
    };
}

macro_rules! internal_path_copies {
    (
        $(
            $dest: expr => (
                $src_rev: expr,
                $src_path: expr,
                $src_overwrite: tt $(,)?
            )
        ),*
        $(,)*
    ) => {
        map!(OrdMap<_, _> {$(
            String::from($dest) => (
                $src_rev,
                $src_path,
                set!(OrdSet<Revision> $src_overwrite)
            )
        ),*})
    };
}

macro_rules! combine_changeset_copies {
    (
        $children_count: tt,
        [
            $(
                {
                    rev: $rev: expr,
                    p1: $p1: expr,
                    p2: $p2: expr,
                    actions: [
                        $(
                            $Action: ident($( $action_path: expr ),+)
                        ),*
                        $(,)?
                    ],
                    merge_cases: $merge: tt
                    $(,)?
                }
            ),*
            $(,)?
        ],
        $target_rev: expr $(,)*
    ) => {{
        let count = map!(HashMap<Revision, usize> $children_count);
        let mut combine_changeset_copies = CombineChangesetCopies::new(count);
        $(
            let actions = vec![$(
                $Action($( HgPath::new($action_path) ),*)
            ),*];
            combine_changeset_copies.add_revision_inner(
                $rev, $p1, $p2, actions.into_iter(),
                merge_case_callback! $merge
            );
        )*
        combine_changeset_copies.finish($target_rev)
    }};
}

macro_rules! path_copies {
    (
        $( $expected_destination: expr => $expected_source: expr ),* $(,)?
    ) => {
        map!(PathCopies {$(
            HgPath::new($expected_destination).to_owned()
                => HgPath::new($expected_source).to_owned(),
        ),*})
    };
}