Add better support for nested recursive aliases.

Author: Alexhuszagh

src/cli.rs

@@ -180,20 +180,22 @@ fn parse_subcommand(
     result: &mut Args,
     target_list: &TargetList,
     config: &CargoConfig,
-    parent: Option<&str>,
+    seen: &mut Vec<String>,
 ) -> Result<()> {
-    if parent == Some(&arg) {
+    if seen.iter().position(|x| x == &arg).is_some() {
+        let chain = seen.join(" -> ");
         MessageInfo::default().fatal(
-            format_args!("alias {arg} has unresolvable recursive definition: {arg} -> {arg}"),
+            format_args!("alias {arg} has unresolvable recursive definition: {chain} -> {arg}"),
             shell::ERROR_CODE,
         );
     }
     let subcommand = Subcommand::from(arg.as_ref());
     if subcommand == Subcommand::Other {
         if let Some(alias) = config.alias(&arg)? {
+            seen.push(arg);
             let mut iter = alias.iter().cloned();
             while let Some(subarg) = iter.next() {
-                parse_arg(subarg, result, target_list, config, &mut iter, Some(&arg))?;
+                parse_arg(subarg, result, target_list, config, seen, &mut iter)?;
             }
             return Ok(());
         }
@@ -212,8 +214,8 @@ fn parse_arg(
     result: &mut Args,
     target_list: &TargetList,
     config: &CargoConfig,
+    seen: &mut Vec<String>,
     iter: &mut impl Iterator<Item = String>,
-    parent_subcommand: Option<&str>,
 ) -> Result<()> {
     if arg.is_empty() {
         return Ok(());
@@ -310,7 +312,7 @@ fn parse_arg(
             }
         }
     } else if (!arg.starts_with('-') || arg == "--list") && result.subcommand.is_none() {
-        parse_subcommand(arg, result, target_list, config, parent_subcommand)?;
+        parse_subcommand(arg, result, target_list, config, seen)?;
     } else {
         result.all.push(arg.clone());
     }
@@ -321,8 +323,9 @@ fn parse_arg(
 pub fn parse(target_list: &TargetList, config: &CargoConfig) -> Result<Args> {
     let mut result = Args::default();
     let mut args = env::args().skip(1);
+    let mut seen = vec![];
     while let Some(arg) = args.next() {
-        parse_arg(arg, &mut result, target_list, config, &mut args, None)?;
+        parse_arg(arg, &mut result, target_list, config, &mut seen, &mut args)?;
     }
 
     Ok(result)
@@ -334,6 +337,12 @@ mod tests {
     use crate::rustc;
     use crate::shell::Verbosity;
 
+    macro_rules! s {
+        ($s:literal) => {
+            $s.to_owned()
+        };
+    }
+
     #[test]
     fn is_verbose_test() {
         assert!(!is_verbose("b"));
@@ -346,6 +355,23 @@ mod tests {
         assert!(!is_verbose("-version"));
     }
 
+    #[test]
+    fn test_nested_alias() {
+        let mut args = Args::default();
+        let target_list =
+            rustc::target_list(&mut Verbosity::Quiet.into()).expect("failed to get target list");
+        let config = CargoConfig::new(None);
+
+        parse_subcommand(
+            "g".to_owned(),
+            &mut args,
+            &target_list,
+            &config,
+            &mut vec![s!("x"), s!("y"), s!("z"), s!("a"), s!("e"), s!("f")],
+        )
+        .ok();
+    }
+
     #[test]
     #[should_panic]
     fn test_recursive_alias() {
@@ -359,7 +385,25 @@ mod tests {
             &mut args,
             &target_list,
             &config,
-            Some("recursive"),
+            &mut vec![s!("recursive")],
+        )
+        .ok();
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_nested_recursive_alias() {
+        let mut args = Args::default();
+        let target_list =
+            rustc::target_list(&mut Verbosity::Quiet.into()).expect("failed to get target list");
+        let config = CargoConfig::new(None);
+
+        parse_subcommand(
+            "y".to_owned(),
+            &mut args,
+            &target_list,
+            &config,
+            &mut vec![s!("x"), s!("y"), s!("z"), s!("a")],
         )
         .ok();
     }