diff --git a/CHANGELOG.md b/CHANGELOG.md index d5b3ee780..8c2b363e4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 * `jj log` output is now topologically grouped. [#242](https://github.com/martinvonz/jj/issues/242) +* The `:` revset operator can now be written as `::` instead. We plan to + delete the `:` form in jj 0.15+. + ### Fixed bugs ## [0.8.0] - 2023-07-09 diff --git a/docs/config.md b/docs/config.md index 57294b253..7efcc1a7f 100644 --- a/docs/config.md +++ b/docs/config.md @@ -196,7 +196,7 @@ To get shorter prefixes for certain revisions, set `revsets.short-prefixes`: ```toml # Prioritize the current branch -revsets.short-prefixes = "(main..@):" +revsets.short-prefixes = "(main..@)::" ``` ### Relative timestamps @@ -259,7 +259,7 @@ You can define aliases for commands, including their arguments. For example: ```toml # `jj l` shows commits on the working-copy commit's (anonymous) branch # compared to the `main` branch -aliases.l = ["log", "-r", "(main..@): | (main..@)-"] +aliases.l = ["log", "-r", "(main..@):: | (main..@)-"] ``` ## Editor diff --git a/docs/github.md b/docs/github.md index 5666be516..c09107ffa 100644 --- a/docs/github.md +++ b/docs/github.md @@ -148,7 +148,7 @@ remote Log all remote branches, which you authored or committed to `jj log -r 'remote_branches() & (committer(your@email.com) | author(your@email.com))'` Log all descendants of the current working copy, which aren't on a remote -`jj log -r ':@ & ~remote_branches()'` +`jj log -r '::@ & ~remote_branches()'` ## Merge conflicts diff --git a/docs/revsets.md b/docs/revsets.md index f5a135b01..a796f90bb 100644 --- a/docs/revsets.md +++ b/docs/revsets.md @@ -58,14 +58,16 @@ only symbols. * `~x`: Revisions that are not in `x`. * `x-`: Parents of `x`. * `x+`: Children of `x`. -* `:x`: Ancestors of `x`, including the commits in `x` itself. -* `x:`: Descendants of `x`, including the commits in `x` itself. -* `x:y`: Descendants of `x` that are also ancestors of `y`. Equivalent to - `x: & :y`. This is what `git log` calls `--ancestry-path x..y`. +* `::x`: Ancestors of `x`, including the commits in `x` itself. +* `x::`: Descendants of `x`, including the commits in `x` itself. +* `x::y`: Descendants of `x` that are also ancestors of `y`. Equivalent + to `x:: & ::y`. This is what `git log` calls `--ancestry-path x..y`. +* `:x`, `x:`, and `x:y`: Deprecated synonyms for `::x`, `x::`, and `x::y`. We + plan to delete them in jj 0.15+. * `x..y`: Ancestors of `y` that are not also ancestors of `x`. Equivalent to - `:y ~ :x`. This is what `git log` calls `x..y` (i.e. the same as we call it). + `::y ~ ::x`. This is what `git log` calls `x..y` (i.e. the same as we call it). * `..x`: Ancestors of `x`, including the commits in `x` itself. Equivalent to - `:x` and provided for consistency. + `::x` and provided for consistency. * `x..`: Revisions that are not ancestors of `x`. You can use parentheses to control evaluation order, such as `(x & y) | z` or @@ -78,9 +80,9 @@ revsets (expressions) as arguments. * `parents(x)`: Same as `x-`. * `children(x)`: Same as `x+`. -* `ancestors(x)`: Same as `:x`. -* `descendants(x)`: Same as `x:`. -* `connected(x)`: Same as `x:x`. Useful when `x` includes several commits. +* `ancestors(x)`: Same as `::x`. +* `descendants(x)`: Same as `x::`. +* `connected(x)`: Same as `x::x`. Useful when `x` includes several commits. * `all()`: All visible commits in the repo. * `none()`: No commits. This function is rarely useful; it is provided for completeness. @@ -169,7 +171,7 @@ jj log -r 'remote_branches(remote=origin)..' Show all ancestors of the working copy (almost like plain `git log`) ``` -jj log -r :@ +jj log -r ::@ ``` Show the initial commits in the repo (the ones Git calls "root commits"): @@ -187,8 +189,9 @@ jj log -r 'tags() | branches()' Show local commits leading up to the working copy, as well as descendants of those commits: + ``` -jj log -r '(remote_branches()..@):' +jj log -r '(remote_branches()..@)::' ``` Show commits authored by "martinvonz" and containing the word "reset" in the diff --git a/docs/tutorial.md b/docs/tutorial.md index 6d7b5ec97..143b9af26 100644 --- a/docs/tutorial.md +++ b/docs/tutorial.md @@ -159,7 +159,7 @@ called the "root commit". It's the root commit of every repo. The `root` symbol in the revset matches it. There are also operators for getting the parents (`foo-`), children (`foo+`), -ancestors (`:foo`), descendants (`foo:`), DAG range (`foo:bar`, like +ancestors (`::foo`), descendants (`foo::`), DAG range (`foo::bar`, like `git log --ancestry-path`), range (`foo..bar`, same as Git's). There are also a few more functions, such as `heads()`, which filters out revisions in the input set if they're ancestors of other revisions in the set. @@ -345,7 +345,7 @@ $ jj new -m ABC; printf 'A\nB\nc\n' > file Working copy now at: 6f30cd1fb351 ABC $ jj new -m ABCD; printf 'A\nB\nC\nD\n' > file Working copy now at: a67491542e10 ABCD -$ jj log -r master:@ +$ jj log -r master::@ @ mrxqplykzpkw martinvonz@google.com 2023-02-12 19:38:21.000 -08:00 b98c607bf87f │ ABCD ◉ kwtuwqnmqyqp martinvonz@google.com 2023-02-12 19:38:12.000 -08:00 30aecc0871ea diff --git a/lib/src/default_index_store.rs b/lib/src/default_index_store.rs index c6ecc326a..8594f539e 100644 --- a/lib/src/default_index_store.rs +++ b/lib/src/default_index_store.rs @@ -2951,7 +2951,7 @@ mod tests { ); // Merge range with sub-range (1..4 + 2..3 should be 1..4, not 1..3): - // 8,7,6->5:1..4, B5_1->5:2..3 + // 8,7,6->5::1..4, B5_1->5::2..3 assert_eq!( walk_commit_ids( &[&ids[8], &ids[7], &ids[6], &id_branch5_1].map(Clone::clone), diff --git a/lib/src/default_revset_engine.rs b/lib/src/default_revset_engine.rs index b7b1e1034..96274cd5d 100644 --- a/lib/src/default_revset_engine.rs +++ b/lib/src/default_revset_engine.rs @@ -712,7 +712,7 @@ impl<'index> EvaluationContext<'index> { } } - /// Calculates `root_set:head_set`. + /// Calculates `root_set::head_set`. fn collect_dag_range<'a, 'b, S, T>( &self, root_set: &S, diff --git a/lib/src/revset.pest b/lib/src/revset.pest index 9d9f9a3e0..58d613a19 100644 --- a/lib/src/revset.pest +++ b/lib/src/revset.pest @@ -28,15 +28,19 @@ parents_op = { "-" } children_op = { "+" } compat_parents_op = { "^" } -dag_range_op = { ":" } -dag_range_pre_op = { ":" } -dag_range_post_op = { ":" } +dag_range_op = { "::" } +dag_range_pre_op = { "::" } +dag_range_post_op = { "::" } +// TODO: Drop support for these in 0.15+ +legacy_dag_range_op = { ":" } +legacy_dag_range_pre_op = { ":" } +legacy_dag_range_post_op = { ":" } range_op = { ".." } range_pre_op = { ".." } range_post_op = { ".." } -range_ops = _{ dag_range_op | range_op } -range_pre_ops = _{ dag_range_pre_op | range_pre_op } -range_post_ops = _{ dag_range_post_op | range_post_op } +range_ops = _{ dag_range_op | legacy_dag_range_op | range_op } +range_pre_ops = _{ dag_range_pre_op | legacy_dag_range_pre_op | range_pre_op } +range_post_ops = _{ dag_range_post_op | legacy_dag_range_post_op | range_post_op } negate_op = { "~" } union_op = { "|" } diff --git a/lib/src/revset.rs b/lib/src/revset.rs index 33043f67d..b854844f9 100644 --- a/lib/src/revset.rs +++ b/lib/src/revset.rs @@ -246,10 +246,12 @@ pub enum RevsetExpression { Ancestors { heads: Rc, generation: Range, + is_legacy: bool, }, Descendants { roots: Rc, generation: Range, + is_legacy: bool, }, // Commits that are ancestors of "heads" but not ancestors of "roots" Range { @@ -261,6 +263,7 @@ pub enum RevsetExpression { DagRange { roots: Rc, heads: Rc, + is_legacy: bool, // TODO: maybe add generation_from_roots/heads? }, Heads(Rc), @@ -357,6 +360,7 @@ impl RevsetExpression { Rc::new(RevsetExpression::Ancestors { heads: self.clone(), generation: 1..2, + is_legacy: false, }) } @@ -365,6 +369,14 @@ impl RevsetExpression { Rc::new(RevsetExpression::Ancestors { heads: self.clone(), generation: GENERATION_RANGE_FULL, + is_legacy: false, + }) + } + fn legacy_ancestors(self: &Rc) -> Rc { + Rc::new(RevsetExpression::Ancestors { + heads: self.clone(), + generation: GENERATION_RANGE_FULL, + is_legacy: true, }) } @@ -373,6 +385,7 @@ impl RevsetExpression { Rc::new(RevsetExpression::Descendants { roots: self.clone(), generation: 1..2, + is_legacy: false, }) } @@ -381,6 +394,14 @@ impl RevsetExpression { Rc::new(RevsetExpression::Descendants { roots: self.clone(), generation: GENERATION_RANGE_FULL, + is_legacy: false, + }) + } + fn legacy_descendants(self: &Rc) -> Rc { + Rc::new(RevsetExpression::Descendants { + roots: self.clone(), + generation: GENERATION_RANGE_FULL, + is_legacy: true, }) } @@ -393,6 +414,17 @@ impl RevsetExpression { Rc::new(RevsetExpression::DagRange { roots: self.clone(), heads: heads.clone(), + is_legacy: false, + }) + } + pub fn legacy_dag_range_to( + self: &Rc, + heads: &Rc, + ) -> Rc { + Rc::new(RevsetExpression::DagRange { + roots: self.clone(), + heads: heads.clone(), + is_legacy: true, }) } @@ -737,9 +769,15 @@ fn parse_expression_rule( | Op::infix(Rule::compat_sub_op, Assoc::Left)) .op(Op::prefix(Rule::negate_op)) // Ranges can't be nested without parentheses. Associativity doesn't matter. - .op(Op::infix(Rule::dag_range_op, Assoc::Left) | Op::infix(Rule::range_op, Assoc::Left)) - .op(Op::prefix(Rule::dag_range_pre_op) | Op::prefix(Rule::range_pre_op)) - .op(Op::postfix(Rule::dag_range_post_op) | Op::postfix(Rule::range_post_op)) + .op(Op::infix(Rule::dag_range_op, Assoc::Left) + | Op::infix(Rule::legacy_dag_range_op, Assoc::Left) + | Op::infix(Rule::range_op, Assoc::Left)) + .op(Op::prefix(Rule::dag_range_pre_op) + | Op::prefix(Rule::legacy_dag_range_pre_op) + | Op::prefix(Rule::range_pre_op)) + .op(Op::postfix(Rule::dag_range_post_op) + | Op::postfix(Rule::legacy_dag_range_post_op) + | Op::postfix(Rule::range_post_op)) // Neighbors .op(Op::postfix(Rule::parents_op) | Op::postfix(Rule::children_op) @@ -750,10 +788,12 @@ fn parse_expression_rule( .map_prefix(|op, rhs| match op.as_rule() { Rule::negate_op => Ok(rhs?.negated()), Rule::dag_range_pre_op | Rule::range_pre_op => Ok(rhs?.ancestors()), + Rule::legacy_dag_range_pre_op => Ok(rhs?.legacy_ancestors()), r => panic!("unexpected prefix operator rule {r:?}"), }) .map_postfix(|lhs, op| match op.as_rule() { Rule::dag_range_post_op => Ok(lhs?.descendants()), + Rule::legacy_dag_range_post_op => Ok(lhs?.legacy_descendants()), Rule::range_post_op => Ok(lhs?.range(&RevsetExpression::visible_heads())), Rule::parents_op => Ok(lhs?.parents()), Rule::children_op => Ok(lhs?.children()), @@ -767,6 +807,7 @@ fn parse_expression_rule( Rule::difference_op => Ok(lhs?.minus(&rhs?)), Rule::compat_sub_op => Err(not_infix_op(&op, "~", "difference")), Rule::dag_range_op => Ok(lhs?.dag_range_to(&rhs?)), + Rule::legacy_dag_range_op => Ok(lhs?.legacy_dag_range_to(&rhs?)), Rule::range_op => Ok(lhs?.range(&rhs?)), r => panic!("unexpected infix operator rule {r:?}"), }) @@ -1276,16 +1317,20 @@ fn try_transform_expression( RevsetExpression::All => None, RevsetExpression::Commits(_) => None, RevsetExpression::CommitRef(_) => None, - RevsetExpression::Ancestors { heads, generation } => transform_rec(heads, pre, post)? - .map(|heads| RevsetExpression::Ancestors { - heads, - generation: generation.clone(), - }), - RevsetExpression::Descendants { roots, generation } => transform_rec(roots, pre, post)? - .map(|roots| RevsetExpression::Descendants { - roots, - generation: generation.clone(), - }), + RevsetExpression::Ancestors { + heads, generation, .. + } => transform_rec(heads, pre, post)?.map(|heads| RevsetExpression::Ancestors { + heads, + generation: generation.clone(), + is_legacy: false, + }), + RevsetExpression::Descendants { + roots, generation, .. + } => transform_rec(roots, pre, post)?.map(|roots| RevsetExpression::Descendants { + roots, + generation: generation.clone(), + is_legacy: false, + }), RevsetExpression::Range { roots, heads, @@ -1297,9 +1342,14 @@ fn try_transform_expression( generation: generation.clone(), } }), - RevsetExpression::DagRange { roots, heads } => { - transform_rec_pair((roots, heads), pre, post)? - .map(|(roots, heads)| RevsetExpression::DagRange { roots, heads }) + RevsetExpression::DagRange { roots, heads, .. } => { + transform_rec_pair((roots, heads), pre, post)?.map(|(roots, heads)| { + RevsetExpression::DagRange { + roots, + heads, + is_legacy: false, + } + }) } RevsetExpression::Heads(candidates) => { transform_rec(candidates, pre, post)?.map(RevsetExpression::Heads) @@ -1493,10 +1543,13 @@ fn fold_difference(expression: &Rc) -> TransformedExpression { match (expression.as_ref(), complement.as_ref()) { // :heads & ~(:roots) -> roots..heads ( - RevsetExpression::Ancestors { heads, generation }, + RevsetExpression::Ancestors { + heads, generation, .. + }, RevsetExpression::Ancestors { heads: roots, generation: GENERATION_RANGE_FULL, + .. }, ) => Rc::new(RevsetExpression::Range { roots: roots.clone(), @@ -1540,6 +1593,7 @@ fn unfold_difference(expression: &Rc) -> TransformedExpression let heads_ancestors = Rc::new(RevsetExpression::Ancestors { heads: heads.clone(), generation: generation.clone(), + is_legacy: false, }); Some(heads_ancestors.intersection(&roots.ancestors().negated())) } @@ -1568,6 +1622,7 @@ fn fold_generation(expression: &Rc) -> TransformedExpression { RevsetExpression::Ancestors { heads, generation: generation1, + .. } => { match heads.as_ref() { // (h-)- -> ancestors(ancestors(h, 1), 1) -> ancestors(h, 2) @@ -1576,9 +1631,11 @@ fn fold_generation(expression: &Rc) -> TransformedExpression { RevsetExpression::Ancestors { heads, generation: generation2, + .. } => Some(Rc::new(RevsetExpression::Ancestors { heads: heads.clone(), generation: add_generation(generation1, generation2), + is_legacy: false, })), _ => None, } @@ -1586,6 +1643,7 @@ fn fold_generation(expression: &Rc) -> TransformedExpression { RevsetExpression::Descendants { roots, generation: generation1, + .. } => { match roots.as_ref() { // (r+)+ -> descendants(descendants(r, 1), 1) -> descendants(r, 2) @@ -1594,9 +1652,11 @@ fn fold_generation(expression: &Rc) -> TransformedExpression { RevsetExpression::Descendants { roots, generation: generation2, + .. } => Some(Rc::new(RevsetExpression::Descendants { roots: roots.clone(), generation: add_generation(generation1, generation2), + is_legacy: false, })), _ => None, } @@ -1986,11 +2046,15 @@ impl VisibilityResolutionContext<'_> { RevsetExpression::CommitRef(_) => { panic!("Expression '{expression:?}' should have been resolved by caller"); } - RevsetExpression::Ancestors { heads, generation } => ResolvedExpression::Ancestors { + RevsetExpression::Ancestors { + heads, generation, .. + } => ResolvedExpression::Ancestors { heads: self.resolve(heads).into(), generation: generation.clone(), }, - RevsetExpression::Descendants { roots, generation } => ResolvedExpression::DagRange { + RevsetExpression::Descendants { + roots, generation, .. + } => ResolvedExpression::DagRange { roots: self.resolve(roots).into(), heads: self.resolve_visible_heads().into(), generation_from_roots: generation.clone(), @@ -2004,7 +2068,7 @@ impl VisibilityResolutionContext<'_> { heads: self.resolve(heads).into(), generation: generation.clone(), }, - RevsetExpression::DagRange { roots, heads } => ResolvedExpression::DagRange { + RevsetExpression::DagRange { roots, heads, .. } => ResolvedExpression::DagRange { roots: self.resolve(roots).into(), heads: self.resolve(heads).into(), generation_from_roots: GENERATION_RANGE_FULL, @@ -2266,6 +2330,7 @@ mod tests { Rc::new(RevsetExpression::Ancestors { heads: wc_symbol.clone(), generation: 1..2, + is_legacy: false, }) ); assert_eq!( @@ -2273,13 +2338,15 @@ mod tests { Rc::new(RevsetExpression::Ancestors { heads: wc_symbol.clone(), generation: GENERATION_RANGE_FULL, + is_legacy: false, }) ); assert_eq!( foo_symbol.children(), Rc::new(RevsetExpression::Descendants { roots: foo_symbol.clone(), - generation: 1..2 + generation: 1..2, + is_legacy: false, }), ); assert_eq!( @@ -2287,6 +2354,7 @@ mod tests { Rc::new(RevsetExpression::Descendants { roots: foo_symbol.clone(), generation: GENERATION_RANGE_FULL, + is_legacy: false, }) ); assert_eq!( @@ -2294,6 +2362,7 @@ mod tests { Rc::new(RevsetExpression::DagRange { roots: foo_symbol.clone(), heads: wc_symbol.clone(), + is_legacy: false, }) ); assert_eq!( @@ -2301,6 +2370,7 @@ mod tests { Rc::new(RevsetExpression::DagRange { roots: foo_symbol.clone(), heads: foo_symbol.clone(), + is_legacy: false, }) ); assert_eq!( @@ -2420,11 +2490,11 @@ mod tests { // Parse the "children" operator assert_eq!(parse("@+"), Ok(wc_symbol.children())); // Parse the "ancestors" operator - assert_eq!(parse(":@"), Ok(wc_symbol.ancestors())); + assert_eq!(parse("::@"), Ok(wc_symbol.ancestors())); // Parse the "descendants" operator - assert_eq!(parse("@:"), Ok(wc_symbol.descendants())); + assert_eq!(parse("@::"), Ok(wc_symbol.descendants())); // Parse the "dag range" operator - assert_eq!(parse("foo:bar"), Ok(foo_symbol.dag_range_to(&bar_symbol))); + assert_eq!(parse("foo::bar"), Ok(foo_symbol.dag_range_to(&bar_symbol))); // Parse the "range" prefix operator assert_eq!(parse("..@"), Ok(wc_symbol.ancestors())); assert_eq!( @@ -2447,10 +2517,10 @@ mod tests { // Parentheses are allowed before suffix operators assert_eq!(parse("(@)-"), Ok(wc_symbol.parents())); // Space is allowed around expressions - assert_eq!(parse(" :@ "), Ok(wc_symbol.ancestors())); - assert_eq!(parse("( :@ )"), Ok(wc_symbol.ancestors())); + assert_eq!(parse(" ::@ "), Ok(wc_symbol.ancestors())); + assert_eq!(parse("( ::@ )"), Ok(wc_symbol.ancestors())); // Space is not allowed around prefix operators - assert_eq!(parse(" : @ "), Err(RevsetParseErrorKind::SyntaxError)); + assert_eq!(parse(" :: @ "), Err(RevsetParseErrorKind::SyntaxError)); // Incomplete parse assert_eq!(parse("foo | -"), Err(RevsetParseErrorKind::SyntaxError)); // Space is allowed around infix operators and function arguments @@ -2565,12 +2635,15 @@ mod tests { assert_eq!(parse("x|y&z").unwrap(), parse("x|(y&z)").unwrap()); assert_eq!(parse("x|y~z").unwrap(), parse("x|(y~z)").unwrap()); // Parse repeated "ancestors"/"descendants"/"dag range"/"range" operators - assert_eq!(parse(":foo:"), Err(RevsetParseErrorKind::SyntaxError)); - assert_eq!(parse("::foo"), Err(RevsetParseErrorKind::SyntaxError)); - assert_eq!(parse("foo::"), Err(RevsetParseErrorKind::SyntaxError)); - assert_eq!(parse("foo::bar"), Err(RevsetParseErrorKind::SyntaxError)); - assert_eq!(parse(":foo:bar"), Err(RevsetParseErrorKind::SyntaxError)); - assert_eq!(parse("foo:bar:"), Err(RevsetParseErrorKind::SyntaxError)); + assert_eq!(parse("::foo::"), Err(RevsetParseErrorKind::SyntaxError)); + assert_eq!(parse(":::foo"), Err(RevsetParseErrorKind::SyntaxError)); + assert_eq!(parse("::::foo"), Err(RevsetParseErrorKind::SyntaxError)); + assert_eq!(parse("foo:::"), Err(RevsetParseErrorKind::SyntaxError)); + assert_eq!(parse("foo::::"), Err(RevsetParseErrorKind::SyntaxError)); + assert_eq!(parse("foo:::bar"), Err(RevsetParseErrorKind::SyntaxError)); + assert_eq!(parse("foo::::bar"), Err(RevsetParseErrorKind::SyntaxError)); + assert_eq!(parse("::foo::bar"), Err(RevsetParseErrorKind::SyntaxError)); + assert_eq!(parse("foo::bar::"), Err(RevsetParseErrorKind::SyntaxError)); assert_eq!(parse("....foo"), Err(RevsetParseErrorKind::SyntaxError)); assert_eq!(parse("foo...."), Err(RevsetParseErrorKind::SyntaxError)); assert_eq!(parse("foo.....bar"), Err(RevsetParseErrorKind::SyntaxError)); @@ -2579,8 +2652,8 @@ mod tests { // Parse combinations of "parents"/"children" operators and the range operators. // The former bind more strongly. assert_eq!(parse("foo-+"), Ok(foo_symbol.parents().children())); - assert_eq!(parse("foo-:"), Ok(foo_symbol.parents().descendants())); - assert_eq!(parse(":foo+"), Ok(foo_symbol.children().ancestors())); + assert_eq!(parse("foo-::"), Ok(foo_symbol.parents().descendants())); + assert_eq!(parse("::foo+"), Ok(foo_symbol.children().ancestors())); } #[test] @@ -3531,6 +3604,7 @@ mod tests { ), ), generation: 1..2, + is_legacy: false, }, ), CommitRef( @@ -3569,6 +3643,7 @@ mod tests { ), ), generation: 1..2, + is_legacy: false, }, ), Filter( @@ -3886,6 +3961,7 @@ mod tests { ), ), generation: 2..3, + is_legacy: false, } "###); insta::assert_debug_snapshot!(optimize(parse(":(foo---)").unwrap()), @r###" @@ -3896,6 +3972,7 @@ mod tests { ), ), generation: 3..18446744073709551615, + is_legacy: false, } "###); insta::assert_debug_snapshot!(optimize(parse("(:foo)---").unwrap()), @r###" @@ -3906,6 +3983,7 @@ mod tests { ), ), generation: 3..18446744073709551615, + is_legacy: false, } "###); @@ -3919,8 +3997,10 @@ mod tests { ), ), generation: 3..4, + is_legacy: false, }, generation: 1..2, + is_legacy: false, } "###); @@ -3951,6 +4031,7 @@ mod tests { ), ), generation: 3..18446744073709551615, + is_legacy: false, }, Ancestors { heads: CommitRef( @@ -3959,6 +4040,7 @@ mod tests { ), ), generation: 2..18446744073709551615, + is_legacy: false, }, ) "###); @@ -3981,6 +4063,7 @@ mod tests { generation: 0..18446744073709551615, }, generation: 2..3, + is_legacy: false, } "###); insta::assert_debug_snapshot!(optimize(parse("foo..(bar..baz)").unwrap()), @r###" @@ -4014,6 +4097,7 @@ mod tests { Rc::new(RevsetExpression::Ancestors { heads, generation: GENERATION_RANGE_EMPTY, + is_legacy: false, }) }; insta::assert_debug_snapshot!( @@ -4028,6 +4112,7 @@ mod tests { ), ), generation: 0..0, + is_legacy: false, } "### ); @@ -4043,6 +4128,7 @@ mod tests { ), ), generation: 0..0, + is_legacy: false, } "### ); @@ -4059,6 +4145,7 @@ mod tests { ), ), generation: 2..3, + is_legacy: false, } "###); insta::assert_debug_snapshot!(optimize(parse("(foo+++):").unwrap()), @r###" @@ -4069,6 +4156,7 @@ mod tests { ), ), generation: 3..18446744073709551615, + is_legacy: false, } "###); insta::assert_debug_snapshot!(optimize(parse("(foo:)+++").unwrap()), @r###" @@ -4079,6 +4167,7 @@ mod tests { ), ), generation: 3..18446744073709551615, + is_legacy: false, } "###); @@ -4092,8 +4181,10 @@ mod tests { ), ), generation: 3..4, + is_legacy: false, }, generation: 1..2, + is_legacy: false, } "###); @@ -4109,12 +4200,14 @@ mod tests { ), ), generation: 2..3, + is_legacy: false, }, heads: CommitRef( Symbol( "bar", ), ), + is_legacy: false, } "###); } diff --git a/lib/src/revset_graph.rs b/lib/src/revset_graph.rs index a36c03967..29ea2a56b 100644 --- a/lib/src/revset_graph.rs +++ b/lib/src/revset_graph.rs @@ -678,7 +678,7 @@ mod tests { A "###); - // A:F is picked at A, and A will be unblocked. Then, C:D at C, ... + // A::F is picked at A, and A will be unblocked. Then, C::D at C, ... insta::assert_snapshot!(format_graph(topo_grouped(graph.iter().cloned())), @r###" G direct(A) │ @@ -730,7 +730,7 @@ mod tests { A "###); - // A:K is picked at A, and A will be unblocked. Then, H:I at H, ... + // A::K is picked at A, and A will be unblocked. Then, H::I at H, ... insta::assert_snapshot!(format_graph(topo_grouped(graph.iter().cloned())), @r###" L direct(A) │ @@ -793,7 +793,7 @@ mod tests { A "###); - // A:K is picked at A, and A will be unblocked. Then, E:G at E, ... + // A::K is picked at A, and A will be unblocked. Then, E::G at E, ... insta::assert_snapshot!(format_graph(topo_grouped(graph.iter().cloned())), @r###" L direct(A) │ @@ -855,7 +855,8 @@ mod tests { │ ~ "###); - // K-E,J is resolved without queuing new heads. Then, G:H, F:I, B:C, and A:D. + // K-E,J is resolved without queuing new heads. Then, G::H, F::I, B::C, and + // A::D. insta::assert_snapshot!(format_graph(topo_grouped(graph.iter().cloned())), @r###" K direct(E), direct(J) ├─╮ @@ -919,7 +920,8 @@ mod tests { │ ~ "###); - // K-I,J is resolved without queuing new heads. Then, D:F, B:H, C:E, and A:G. + // K-I,J is resolved without queuing new heads. Then, D::F, B::H, C::E, and + // A::G. insta::assert_snapshot!(format_graph(topo_grouped(graph.iter().cloned())), @r###" K direct(I), direct(J) ├─╮ diff --git a/src/commands/mod.rs b/src/commands/mod.rs index 2cd0dbf3c..b6d711d57 100644 --- a/src/commands/mod.rs +++ b/src/commands/mod.rs @@ -782,7 +782,7 @@ struct SplitArgs { /// * all descendants of those commits /// /// In other words, `jj rebase -b X -d Y` rebases commits in the revset -/// `(Y..X):` (which is equivalent to `jj rebase -s 'roots(Y..X)' -d Y` for a +/// `(Y..X)::` (which is equivalent to `jj rebase -s 'roots(Y..X)' -d Y` for a /// single root). For example, either `jj rebase -b L -d O` or `jj rebase -b M /// -d O` would transform your history like this (because `L` and `M` are on the /// same "branch", relative to the destination): diff --git a/testing/bench-revsets-git.txt b/testing/bench-revsets-git.txt index cfab1baf1..602afa143 100644 --- a/testing/bench-revsets-git.txt +++ b/testing/bench-revsets-git.txt @@ -4,21 +4,21 @@ v1.0.0 v2.40.0 # Old history -:v1.0.0 +::v1.0.0 ..v1.0.0 # More history -:v2.40.0 +::v2.40.0 ..v2.40.0 # Only recent history v2.39.0..v2.40.0 -:v2.40.0 ~ :v2.39.0 -v2.39.0:v2.40.0 +::v2.40.0 ~ ::v2.39.0 +v2.39.0::v2.40.0 # Tags and branches tags() branches() # Intersection of range with a small subset -tags() & :v2.40.0 -v2.39.0 & :v2.40.0 +tags() & ::v2.40.0 +v2.39.0 & ::v2.40.0 # Author and committer author(peff) committer(gitster) @@ -26,8 +26,8 @@ committer(gitster) author(peff) & committer(gitster) author(peff) | committer(gitster) # Intersection of filter with a small subset -:v1.0.0 & (author(peff) & committer(gitster)) -:v1.0.0 & (author(peff) | committer(gitster)) +::v1.0.0 & (author(peff) & committer(gitster)) +::v1.0.0 & (author(peff) | committer(gitster)) # Roots and heads of small subsets roots(tags()) heads(tags()) @@ -35,32 +35,32 @@ heads(tags()) roots(author(peff)) heads(author(peff)) # Roots and heads of range -roots(:v2.40.0) -heads(:v2.40.0) +roots(::v2.40.0) +heads(::v2.40.0) # Parents and ancestors of old commit v1.0.0- v1.0.0--- -:v1.0.0--- +::v1.0.0--- # Children and descendants of old commit v1.0.0+ v1.0.0+++ -v1.0.0+++: +v1.0.0+++:: # Parents and ancestors of recent commit v2.40.0- v2.40.0--- -:v2.40.0--- +::v2.40.0--- # Children and descendants of recent commit v2.40.0+ v2.40.0+++ -v2.40.0+++: +v2.40.0+++:: # Parents and ancestors of small subset tags()- tags()--- -:tags()--- +::tags()--- # Children and descendants of small subset tags()+ tags()+++ -tags()+++: +tags()+++:: # Filter that doesn't read commit object merges() ~merges() diff --git a/tests/test_revset_output.rs b/tests/test_revset_output.rs index 1f7eac1ae..3c5f158ad 100644 --- a/tests/test_revset_output.rs +++ b/tests/test_revset_output.rs @@ -29,7 +29,7 @@ fn test_syntax_error() { 1 | x & | ^--- | - = expected dag_range_pre_op, range_pre_op, negate_op, or primary + = expected dag_range_pre_op, legacy_dag_range_pre_op, range_pre_op, negate_op, or primary "###); let stderr = test_env.jj_cmd_failure(&repo_path, &["log", "-r", "x - y"]); @@ -61,12 +61,12 @@ fn test_bad_function_call() { test_env.jj_cmd_success(test_env.env_root(), &["init", "repo", "--git"]); let repo_path = test_env.env_root().join("repo"); - let stderr = test_env.jj_cmd_failure(&repo_path, &["log", "-r", "all(or:nothing)"]); + let stderr = test_env.jj_cmd_failure(&repo_path, &["log", "-r", "all(or::nothing)"]); insta::assert_snapshot!(stderr, @r###" Error: Failed to parse revset: --> 1:5 | - 1 | all(or:nothing) - | ^--------^ + 1 | all(or::nothing) + | ^---------^ | = Invalid arguments to revset function "all": Expected 0 arguments "###); @@ -141,12 +141,12 @@ fn test_bad_function_call() { = Invalid file pattern: Path "../out" is not in the repo "###); - let stderr = test_env.jj_cmd_failure(&repo_path, &["log", "-r", "root:whatever()"]); + let stderr = test_env.jj_cmd_failure(&repo_path, &["log", "-r", "root::whatever()"]); insta::assert_snapshot!(stderr, @r###" - Error: Failed to parse revset: --> 1:6 + Error: Failed to parse revset: --> 1:7 | - 1 | root:whatever() - | ^------^ + 1 | root::whatever() + | ^------^ | = Revset function "whatever" doesn't exist "###); @@ -279,7 +279,7 @@ fn test_alias() { 1 | whatever & | ^--- | - = expected dag_range_pre_op, range_pre_op, negate_op, or primary + = expected dag_range_pre_op, legacy_dag_range_pre_op, range_pre_op, negate_op, or primary "###); let stderr = test_env.jj_cmd_failure(&repo_path, &["log", "-r", "identity()"]);