revset: add support for local variables expansion

I think this can be used in order to substitute remote name in the default push
revset expression?

push(remote) = remote_bookmarks(remote=remote)..@

lib/src/dsl_util.rs

···
 
 /// Expands aliases recursively in tree of `T`.
 #[derive(Debug)]
-struct AliasExpander<'i, T, P> {
+struct AliasExpander<'i, 'a, T, P> {
     /// Alias symbols and functions that are globally available.
     aliases_map: &'i AliasesMap<P, String>,
+    /// Local variables set in the outermost scope.
+    locals: &'a HashMap<&'i str, ExpressionNode<'i, T>>,
     /// Stack of aliases and local parameters currently expanding.
     states: Vec<AliasExpandingState<'i, T>>,
 }
···
     locals: HashMap<&'i str, ExpressionNode<'i, T>>,
 }
 
-impl<'i, T, P, E> AliasExpander<'i, T, P>
+impl<'i, T, P, E> AliasExpander<'i, '_, T, P>
 where
     T: AliasExpandableExpression<'i> + Clone,
     P: AliasDefinitionParser<Output<'i> = T, Error = E>,
     E: AliasExpandError,
 {
+    /// Local variables available to the current scope.
+    fn current_locals(&self) -> &HashMap<&'i str, ExpressionNode<'i, T>> {
+        self.states.last().map_or(self.locals, |s| &s.locals)
+    }
+
     fn expand_defn(
         &mut self,
         id: AliasId<'i>,
···
     }
 }
 
-impl<'i, T, P, E> ExpressionFolder<'i, T> for AliasExpander<'i, T, P>
+impl<'i, T, P, E> ExpressionFolder<'i, T> for AliasExpander<'i, '_, T, P>
 where
     T: AliasExpandableExpression<'i> + Clone,
     P: AliasDefinitionParser<Output<'i> = T, Error = E>,
···
     type Error = E;
 
     fn fold_identifier(&mut self, name: &'i str, span: pest::Span<'i>) -> Result<T, Self::Error> {
-        if let Some(subst) = self.states.last().and_then(|s| s.locals.get(name)) {
+        if let Some(subst) = self.current_locals().get(name) {
             let id = AliasId::Parameter(name);
             Ok(T::alias_expanded(id, Box::new(subst.clone())))
         } else if let Some((id, defn)) = self.aliases_map.get_symbol(name) {
···
     P: AliasDefinitionParser<Output<'i> = T>,
     P::Error: AliasExpandError,
 {
+    expand_aliases_with_locals(node, aliases_map, &HashMap::new())
+}
+
+/// Expands aliases recursively with the outermost local variables.
+///
+/// Local variables are similar to alias symbols, but are scoped. Alias symbols
+/// are globally accessible from alias expressions, but local variables aren't.
+pub fn expand_aliases_with_locals<'i, T, P>(
+    node: ExpressionNode<'i, T>,
+    aliases_map: &'i AliasesMap<P, String>,
+    locals: &HashMap<&'i str, ExpressionNode<'i, T>>,
+) -> Result<ExpressionNode<'i, T>, P::Error>
+where
+    T: AliasExpandableExpression<'i> + Clone,
+    P: AliasDefinitionParser<Output<'i> = T>,
+    P::Error: AliasExpandError,
+{
     let mut expander = AliasExpander {
         aliases_map,
+        locals,
         states: Vec::new(),
     };
     expander.fold_expression(node)

lib/src/revset_parser.rs

···
 
 #[cfg(test)]
 mod tests {
+    use std::collections::HashMap;
+
     use assert_matches::assert_matches;
 
     use super::*;
     use crate::dsl_util::KeywordArgument;
 
     #[derive(Debug)]
-    struct WithRevsetAliasesMap(RevsetAliasesMap);
+    struct WithRevsetAliasesMap<'i> {
+        aliases_map: RevsetAliasesMap,
+        locals: HashMap<&'i str, ExpressionNode<'i>>,
+    }
+
+    impl<'i> WithRevsetAliasesMap<'i> {
+        fn set_local(mut self, name: &'i str, value: &'i str) -> Self {
+            self.locals.insert(name, parse_program(value).unwrap());
+            self
+        }
 
-    impl WithRevsetAliasesMap {
-        fn parse<'i>(&'i self, text: &'i str) -> Result<ExpressionNode<'i>, RevsetParseError> {
+        fn parse(&'i self, text: &'i str) -> Result<ExpressionNode<'i>, RevsetParseError> {
             let node = parse_program(text)?;
-            dsl_util::expand_aliases(node, &self.0)
+            dsl_util::expand_aliases_with_locals(node, &self.aliases_map, &self.locals)
         }
 
-        fn parse_normalized<'i>(&'i self, text: &'i str) -> ExpressionNode<'i> {
+        fn parse_normalized(&'i self, text: &'i str) -> ExpressionNode<'i> {
             normalize_tree(self.parse(text).unwrap())
         }
     }
 
-    fn with_aliases(
+    fn with_aliases<'i>(
         aliases: impl IntoIterator<Item = (impl AsRef<str>, impl Into<String>)>,
-    ) -> WithRevsetAliasesMap {
+    ) -> WithRevsetAliasesMap<'i> {
         let mut aliases_map = RevsetAliasesMap::new();
         for (decl, defn) in aliases {
             aliases_map.insert(decl, defn).unwrap();
         }
-        WithRevsetAliasesMap(aliases_map)
+        WithRevsetAliasesMap {
+            aliases_map,
+            locals: HashMap::new(),
+        }
     }
 
     fn parse_into_kind(text: &str) -> Result<ExpressionKind, RevsetParseErrorKind> {
···
                 .unwrap_err()
                 .kind,
             RevsetParseErrorKind::InAliasExpansion("F(x)".to_owned())
+        );
+    }
+
+    #[test]
+    fn test_expand_with_locals() {
+        // Local variable should precede the symbol alias.
+        assert_eq!(
+            with_aliases([("A", "symbol")])
+                .set_local("A", "local")
+                .parse_normalized("A"),
+            parse_normalized("local")
+        );
+
+        // Local variable shouldn't be expanded within aliases.
+        assert_eq!(
+            with_aliases([("B", "A"), ("F(x)", "x&A")])
+                .set_local("A", "a")
+                .parse_normalized("A|B|F(A)"),
+            parse_normalized("a|A|(a&A)")
         );
     }
 }