fileset: add alias parser

Additionally, adds alias handling to cli_util.

The implementation is mostly copied from the similar parts in
cli/template_parser.

cli/src/cli_util.rs

@@ -61,8 +61,11 @@ use jj_lib::config::ConfigError;
 use jj_lib::config::ConfigSource;
 use jj_lib::config::StackedConfig;
 use jj_lib::conflicts::ConflictMarkerStyle;
+use jj_lib::dsl_util::AliasDeclarationParser;
+use jj_lib::dsl_util::AliasesMap;
 use jj_lib::file_util;
 use jj_lib::fileset;
+use jj_lib::fileset::FilesetAliasesMap;
 use jj_lib::fileset::FilesetDiagnostics;
 use jj_lib::fileset::FilesetExpression;
 use jj_lib::git;
@@ -340,6 +343,14 @@ impl CommandHelper {
         load_template_aliases(ui, &self.data.stacked_config)
     }
 
+    /// Loads fileset aliases from the configs.
+    ///
+    /// For most commands that depend on a loaded repo, you should use
+    /// `WorkspaceCommandHelper::fileset_aliases_map()` instead.
+    fn load_fileset_aliases(&self, ui: &Ui) -> Result<FilesetAliasesMap, CommandError> {
+        load_fileset_aliases(ui, &self.data.layered_configs)
+    }
+
     /// Parses template of the given language into evaluation tree.
     ///
     /// This function also loads template aliases from the settings. Use
@@ -713,6 +724,7 @@ pub struct WorkspaceCommandEnvironment {
     command: CommandHelper,
     revset_aliases_map: RevsetAliasesMap,
     template_aliases_map: TemplateAliasesMap,
+    fileset_aliases_map: FilesetAliasesMap,
     path_converter: RepoPathUiConverter,
     workspace_id: WorkspaceId,
     immutable_heads_expression: Rc<UserRevsetExpression>,
@@ -726,6 +738,7 @@ impl WorkspaceCommandEnvironment {
         let revset_aliases_map =
             revset_util::load_revset_aliases(ui, &command.data.stacked_config)?;
         let template_aliases_map = command.load_template_aliases(ui)?;
+        let fileset_aliases_map = command.load_fileset_aliases(ui)?;
         let path_converter = RepoPathUiConverter::Fs {
             cwd: command.cwd().to_owned(),
             base: workspace.workspace_root().to_owned(),
@@ -734,6 +747,7 @@ impl WorkspaceCommandEnvironment {
             command: command.clone(),
             revset_aliases_map,
             template_aliases_map,
+            fileset_aliases_map,
             path_converter,
             workspace_id: workspace.workspace_id().to_owned(),
             immutable_heads_expression: RevsetExpression::root(),
@@ -1273,7 +1287,14 @@ to the current parents may contain changes from multiple commits.
         let mut diagnostics = FilesetDiagnostics::new();
         let expressions: Vec<_> = file_args
             .iter()
-            .map(|arg| fileset::parse_maybe_bare(&mut diagnostics, arg, self.path_converter()))
+            .map(|arg| {
+                fileset::parse_maybe_bare(
+                    &mut diagnostics,
+                    arg,
+                    self.path_converter(),
+                    self.fileset_aliases_map(),
+                )
+            })
             .try_collect()?;
         print_parse_diagnostics(ui, "In fileset expression", &diagnostics)?;
         Ok(FilesetExpression::union_all(expressions))
@@ -1289,6 +1310,7 @@ to the current parents may contain changes from multiple commits.
                 cwd: "".into(),
                 base: "".into(),
             },
+            self.fileset_aliases_map(),
         )?;
         print_parse_diagnostics(ui, "In `snapshot.auto-track`", &diagnostics)?;
         Ok(expression.to_matcher())
@@ -1564,6 +1586,10 @@ to the current parents may contain changes from multiple commits.
         &self.env.template_aliases_map
     }
 
+    pub fn fileset_aliases_map(&self) -> &FilesetAliasesMap {
+        &self.env.fileset_aliases_map
+    }
+
     /// Parses template of the given language into evaluation tree.
     ///
     /// `wrap_self` specifies the type of the top-level property, which should
@@ -2694,11 +2720,31 @@ fn load_template_aliases(
     stacked_config: &StackedConfig,
 ) -> Result<TemplateAliasesMap, CommandError> {
     const TABLE_KEY: &str = "template-aliases";
-    let mut aliases_map = TemplateAliasesMap::new();
+    load_aliases(ui, stacked_config, TABLE_KEY)
+}
+
+fn load_fileset_aliases(
+    ui: &Ui,
+    stacked_config: &StackedConfig,
+) -> Result<FilesetAliasesMap, CommandError> {
+    const TABLE_KEY: &str = "fileset-aliases";
+    load_aliases(ui, stacked_config, TABLE_KEY)
+}
+
+fn load_aliases<P>(
+    ui: &Ui,
+    stacked_config: &StackedConfig,
+    table_key: &str,
+) -> Result<AliasesMap<P, String>, CommandError>
+where
+    P: Default + AliasDeclarationParser,
+    P::Error: ToString,
+{
+    let mut aliases_map = AliasesMap::new();
     // Load from all config layers in order. 'f(x)' in default layer should be
     // overridden by 'f(a)' in user.
     for layer in stacked_config.layers() {
-        let table = if let Some(table) = layer.data.get_table(TABLE_KEY).optional()? {
+        let table = if let Some(table) = layer.data.get_table(table_key).optional()? {
             table
         } else {
             continue;
@@ -2707,11 +2753,15 @@ fn load_template_aliases(
             let r = value
                 .into_string()
                 .map_err(|e| e.to_string())
-                .and_then(|v| aliases_map.insert(&decl, v).map_err(|e| e.to_string()));
+                .and_then(|v| {
+                    aliases_map
+                        .insert(&decl, v)
+                        .map_err(|e: P::Error| e.to_string())
+                });
             if let Err(s) = r {
                 writeln!(
                     ui.warning_default(),
-                    r#"Failed to load "{TABLE_KEY}.{decl}": {s}"#
+                    r#"Failed to load "{table_key}.{decl}": {s}"#
                 )?;
             }
         }

cli/src/command_error.rs

@@ -646,6 +646,9 @@ fn fileset_parse_error_hint(err: &FilesetParseError) -> Option<String> {
         FilesetParseErrorKind::InvalidArguments { .. } | FilesetParseErrorKind::Expression(_) => {
             find_source_parse_error_hint(&err)
         }
+        FilesetParseErrorKind::InAliasExpansion(_)
+        | FilesetParseErrorKind::InParameterExpansion(_)
+        | FilesetParseErrorKind::RecursiveAlias(_) => None,
     }
 }
 

cli/src/commands/debug/fileset.rs

@@ -37,9 +37,11 @@ pub fn cmd_debug_fileset(
 ) -> Result<(), CommandError> {
     let workspace_command = command.workspace_helper(ui)?;
     let path_converter = workspace_command.path_converter();
+    let aliases_map = workspace_command.fileset_aliases_map();
 
     let mut diagnostics = FilesetDiagnostics::new();
-    let expression = fileset::parse_maybe_bare(&mut diagnostics, &args.path, path_converter)?;
+    let expression =
+        fileset::parse_maybe_bare(&mut diagnostics, &args.path, path_converter, aliases_map)?;
     print_parse_diagnostics(ui, "In fileset expression", &diagnostics)?;
     writeln!(ui.stdout(), "-- Parsed:")?;
     writeln!(ui.stdout(), "{expression:#?}")?;

cli/src/commands/fix.rs

@@ -492,6 +492,7 @@ fn get_tools_config(ui: &mut Ui, settings: &UserSettings) -> Result<ToolsConfig,
                                     cwd: "".into(),
                                     base: "".into(),
                                 },
+                                &Default::default(),
                             )
                         })
                         .try_collect()?,

cli/src/commit_templater.rs

@@ -854,8 +854,9 @@ fn expect_fileset_literal(
 ) -> Result<FilesetExpression, TemplateParseError> {
     template_parser::expect_string_literal_with(node, |text, span| {
         let mut inner_diagnostics = FilesetDiagnostics::new();
-        let expression =
-            fileset::parse(&mut inner_diagnostics, text, path_converter).map_err(|err| {
+        let aliases_map = Default::default();
+        let expression = fileset::parse(&mut inner_diagnostics, text, path_converter, &aliases_map)
+            .map_err(|err| {
                 TemplateParseError::expression("In fileset expression", span).with_source(err)
             })?;
         diagnostics.extend_with(inner_diagnostics, |diag| {

lib/src/fileset.pest

@@ -89,3 +89,5 @@ program_or_bare_string = _{
         | bare_string_pattern ~ EOI
         | bare_string ~ EOI )
 }
+
+alias_declaration = _{ SOI ~ identifier ~ EOI }

lib/src/fileset.rs

@@ -23,11 +23,14 @@ use itertools::Itertools as _;
 use once_cell::sync::Lazy;
 use thiserror::Error;
 
+use crate::dsl_util;
 use crate::dsl_util::collect_similar;
+use crate::dsl_util::AliasExpandError;
 use crate::fileset_parser;
 use crate::fileset_parser::BinaryOp;
 use crate::fileset_parser::ExpressionKind;
 use crate::fileset_parser::ExpressionNode;
+pub use crate::fileset_parser::FilesetAliasesMap;
 pub use crate::fileset_parser::FilesetDiagnostics;
 pub use crate::fileset_parser::FilesetParseError;
 pub use crate::fileset_parser::FilesetParseErrorKind;
@@ -465,6 +468,15 @@ fn resolve_expression(
         ExpressionKind::FunctionCall(function) => {
             resolve_function(diagnostics, path_converter, function)
         }
+        ExpressionKind::AliasExpanded(id, subst) => {
+            let mut inner_diagnostics = FilesetDiagnostics::new();
+            let expression = resolve_expression(&mut inner_diagnostics, path_converter, subst)
+                .map_err(|e| e.within_alias_expansion(*id, node.span))?;
+            diagnostics.extend_with(inner_diagnostics, |diag| {
+                diag.within_alias_expansion(*id, node.span)
+            });
+            Ok(expression)
+        }
     }
 }
 
@@ -473,9 +485,11 @@ pub fn parse(
     diagnostics: &mut FilesetDiagnostics,
     text: &str,
     path_converter: &RepoPathUiConverter,
+    aliases_map: &FilesetAliasesMap,
 ) -> FilesetParseResult<FilesetExpression> {
     let node = fileset_parser::parse_program(text)?;
     // TODO: add basic tree substitution pass to eliminate redundant expressions
+    let node = dsl_util::expand_aliases(node, aliases_map)?;
     resolve_expression(diagnostics, path_converter, &node)
 }
 
@@ -487,9 +501,11 @@ pub fn parse_maybe_bare(
     diagnostics: &mut FilesetDiagnostics,
     text: &str,
     path_converter: &RepoPathUiConverter,
+    aliases_map: &FilesetAliasesMap,
 ) -> FilesetParseResult<FilesetExpression> {
     let node = fileset_parser::parse_program_or_bare_string(text)?;
     // TODO: add basic tree substitution pass to eliminate redundant expressions
+    let node = dsl_util::expand_aliases(node, aliases_map)?;
     resolve_expression(diagnostics, path_converter, &node)
 }
 
@@ -529,7 +545,15 @@ mod tests {
             cwd: PathBuf::from("/ws/cur"),
             base: PathBuf::from("/ws"),
         };
-        let parse = |text| parse_maybe_bare(&mut FilesetDiagnostics::new(), text, &path_converter);
+        let aliases_map = Default::default();
+        let parse = |text| {
+            parse_maybe_bare(
+                &mut FilesetDiagnostics::new(),
+                text,
+                &path_converter,
+                &aliases_map,
+            )
+        };
 
         // cwd-relative patterns
         insta::assert_debug_snapshot!(
@@ -574,7 +598,15 @@ mod tests {
             cwd: PathBuf::from("/ws/cur*"),
             base: PathBuf::from("/ws"),
         };
-        let parse = |text| parse_maybe_bare(&mut FilesetDiagnostics::new(), text, &path_converter);
+        let aliases_map = Default::default();
+        let parse = |text| {
+            parse_maybe_bare(
+                &mut FilesetDiagnostics::new(),
+                text,
+                &path_converter,
+                &aliases_map,
+            )
+        };
 
         // cwd-relative, without meta characters
         insta::assert_debug_snapshot!(
@@ -747,7 +779,15 @@ mod tests {
             cwd: PathBuf::from("/ws/cur"),
             base: PathBuf::from("/ws"),
         };
-        let parse = |text| parse_maybe_bare(&mut FilesetDiagnostics::new(), text, &path_converter);
+        let aliases_map = Default::default();
+        let parse = |text| {
+            parse_maybe_bare(
+                &mut FilesetDiagnostics::new(),
+                text,
+                &path_converter,
+                &aliases_map,
+            )
+        };
 
         insta::assert_debug_snapshot!(parse("all()").unwrap(), @"All");
         insta::assert_debug_snapshot!(parse("none()").unwrap(), @"None");
@@ -775,7 +815,15 @@ mod tests {
             cwd: PathBuf::from("/ws/cur"),
             base: PathBuf::from("/ws"),
         };
-        let parse = |text| parse_maybe_bare(&mut FilesetDiagnostics::new(), text, &path_converter);
+        let aliases_map = Default::default();
+        let parse = |text| {
+            parse_maybe_bare(
+                &mut FilesetDiagnostics::new(),
+                text,
+                &path_converter,
+                &aliases_map,
+            )
+        };
 
         insta::assert_debug_snapshot!(parse("~x").unwrap(), @r###"
         Difference(