Revsets: independent() and conflicts() 543bbf64d127

            "independent" => {

                self.arity(name, args, 2)?;

                let x = self.eval(&args[0], None)?;

                let inn = self.eval(&args[1], None)?;

                let below = self.ancestors(&x)?;

                let above = self.descendants(&x)?;

                Ok(inn

                    .into_iter()

                    .filter(|h| !below.contains(h) && !above.contains(h))

                    .collect())

            }

            "conflicts" => {

                if args.len() > 1 {

                    return Err(err(

                        "conflicts() takes a state, or nothing for the working copy's",

                    ));

                }

                let heads: Vec<ChangeHash> = match args.first() {

                    Some(e) => self.eval(e, None)?.into_iter().collect(),

                    None => match self.working_copy() {

                        Some(wc) => {

                            self.ensure(&[wc])?;

                            self.graph

                                .get(&wc)

                                .map(|m| m.deps.clone())

                                .unwrap_or_default()

                        }

                        None => self.repo.bookmark_heads()?,

                    },

                };

                self.conflicts(within, &heads)

            }

    }

    /// `conflicts(S)`: the changes that contributed atoms to a conflict in

    /// the state `heads` name (conflicts belong to states, not changes).

    fn conflicts(&mut self, within: Option<&Set>, heads: &[ChangeHash]) -> Result<Set> {

        let state = self.repo.load_state(heads)?;

        let snapshot = state.materialize();

        let mut out = Set::new();

        for f in snapshot.files.values() {

            if !f.is_conflicted() {

                continue;

            }

            match &f.content {

                crate::state::FileContent::Text { .. } => {

                    out.extend(state.conflict_regions(&f.node).contributors);

                }

                crate::state::FileContent::Opaque { blobs } => {

                    out.extend(state.blob_contributors(&f.node, blobs));

                }

                crate::state::FileContent::Dir => {}

            }

            self.tick()?;

        }

        self.ensure(heads)?;

        Ok(match within {

            Some(w) => out.intersection(w).copied().collect(),

            None => out,

        })

                    | "conflicts"

    // independent(X, IN): what could ship without X. c and d neither

    // depend on b nor are depended on by it; a is below, the working copy

    // above.

    assert_eq!(

        set(&format!("independent(#{}, ::@)", b.short(12))),

        sorted(&[c, d])

    );

    assert_eq!(

        set(&format!("independent(#{}, ::main)", a.short(12))),

        vec![c]

    );

    // conflicts(S): nothing conflicts yet; then two edits of one line.

    assert_eq!(set("conflicts()"), vec![]);

    assert_eq!(set("conflicts(main)"), vec![]);

    // (The saved revset above edited the user config under the root:

    // discard it.)

    repo.checkout(&[a], true, "checkout a").unwrap();

    write(root, "src/a.rs", b"one\nTWO\n");

    let e = repo

        .commit("fifth: the other edit of line two", &[])

        .unwrap();

    repo.checkout(&repo.bookmark_heads().unwrap(), true, "checkout main")

        .unwrap();

    let conflicted = repo.revset("conflicts()").unwrap().hashes;

    assert!(

        conflicted.contains(&e) && conflicted.contains(&b),

        "{conflicted:?} should hold b and e"

    );

    assert!(!conflicted.contains(&c));

    assert_eq!(set("conflicts() & author(nobody)"), vec![]);

`touches`, `latest`, `independent`, `conflicts` and the trust predicates

of §2.4 below, saved revsets, and a time budget. Not yet:

| `conflicts(S)` | changes that contributed atoms to a conflict in state S (default: the working copy's base). Conflicts belong to states, not changes. |