feat: improve default labeling in show

src/elan-cli/common.rs

@@ -245,34 +245,10 @@ pub fn lean_version(toolchain: &Toolchain) -> String {
             String::from("(lean does not exist)")
         }
     } else {
-        String::from("(toolchain not installed)")
+        String::from("(toolchain will be installed on first use)")
     }
 }
 
-pub fn list_toolchains(cfg: &Cfg) -> Result<()> {
-    let toolchains = cfg.list_toolchains()?;
-
-    if toolchains.is_empty() {
-        println!("no installed toolchains");
-    } else {
-        if let Ok(Some(def_toolchain)) = cfg.resolve_default() {
-            for toolchain in toolchains {
-                let if_default = if def_toolchain == toolchain {
-                    " (default)"
-                } else {
-                    ""
-                };
-                println!("{}{}", &toolchain, if_default);
-            }
-        } else {
-            for toolchain in toolchains {
-                println!("{}", &toolchain);
-            }
-        }
-    }
-    Ok(())
-}
-
 pub fn list_overrides(cfg: &Cfg) -> Result<()> {
     let overrides = cfg.settings_file.with(|s| Ok(s.overrides.clone()))?;
 

src/elan-cli/elan_mode.rs

@@ -27,7 +27,7 @@ pub fn main() -> Result<()> {
         ("default", Some(m)) => default_(cfg, m)?,
         ("toolchain", Some(c)) => match c.subcommand() {
             ("install", Some(m)) => install(cfg, m)?,
-            ("list", Some(_)) => common::list_toolchains(cfg)?,
+            ("list", Some(_)) => list_toolchains(cfg)?,
             ("link", Some(m)) => toolchain_link(cfg, m)?,
             ("uninstall", Some(m)) => toolchain_remove(cfg, m)?,
             (_, _) => unreachable!(),
@@ -288,6 +288,34 @@ fn which(cfg: &Cfg, m: &ArgMatches) -> Result<()> {
     Ok(())
 }
 
+pub fn mk_toolchain_label(tc: &ToolchainDesc, default_tc: &Option<String>, resolved_default_tc: &Option<ToolchainDesc>) -> String {
+    if resolved_default_tc.as_ref() == Some(&tc) {
+        if default_tc == &resolved_default_tc.as_ref().map(|tc| tc.to_string()) {
+            format!("{} (default)", tc)
+        } else {
+            format!("{} (resolved from default '{}')", tc, default_tc.as_ref().unwrap())
+        }
+    } else {
+        format!("{}", tc)
+    }
+}
+
+pub fn list_toolchains(cfg: &Cfg) -> Result<()> {
+    let toolchains = cfg.list_toolchains()?;
+    let default_tc = cfg.get_default()?;
+    let resolved_default_tc =
+      default_tc.as_ref().map(|tc| lookup_toolchain_desc(cfg, tc)).transpose()?;
+
+    if toolchains.is_empty() {
+        println!("no installed toolchains");
+    } else {
+        for tc in toolchains {
+            println!("{}", mk_toolchain_label(&tc, &default_tc, &resolved_default_tc));
+        }
+    }
+    Ok(())
+}
+
 fn show(cfg: &Cfg) -> Result<()> {
     let ref cwd = utils::current_dir()?;
     let installed_toolchains = cfg.list_toolchains()?;
@@ -303,17 +331,15 @@ fn show(cfg: &Cfg) -> Result<()> {
         .count()
         > 1;
 
+    let default_tc = cfg.get_default()?;
+    let resolved_default_tc =
+      default_tc.as_ref().map(|tc| lookup_toolchain_desc(cfg, tc)).transpose()?;
     if show_installed_toolchains {
         if show_headers {
             print_header("installed toolchains")
         }
-        let default_tc = cfg.resolve_default()?;
         for t in installed_toolchains {
-            if default_tc.as_ref() == Some(&t) {
-                println!("{} (default)", t);
-            } else {
-                println!("{}", t);
-            }
+            println!("{}", mk_toolchain_label(&t, &default_tc, &resolved_default_tc));
         }
         if show_headers {
             println!("")
@@ -332,7 +358,7 @@ fn show(cfg: &Cfg) -> Result<()> {
                     println!("{}", common::lean_version(toolchain));
                 }
                 Some((ref toolchain, None)) => {
-                    println!("{} (default)", toolchain.name());
+                    println!("{}", mk_toolchain_label(&toolchain.desc, &default_tc, &resolved_default_tc));
                     println!("{}", common::lean_version(toolchain));
                 }
                 None => {

src/elan/config.rs

@@ -128,12 +128,14 @@ impl Cfg {
         }
     }
 
-    pub fn resolve_default(&self) -> Result<Option<ToolchainDesc>> {
-        let opt_name = self
+    pub fn get_default(&self) -> Result<Option<String>> {
+        self
             .settings_file
-            .with(|s| Ok(s.default_toolchain.clone()))?;
+            .with(|s| Ok(s.default_toolchain.clone()))
+    }
 
-        if let Some(name) = opt_name {
+    pub fn resolve_default(&self) -> Result<Option<ToolchainDesc>> {
+        if let Some(name) = self.get_default()? {
             let toolchain = lookup_toolchain_desc(&self, &name)?;
             Ok(Some(toolchain))
         } else {