#370 Support for explicit channel argument

src/cli.rs

@@ -1,17 +1,23 @@
 use std::{env, path::PathBuf};
 
+use rustc_version::Channel;
+
 use crate::Target;
 use crate::cargo::Subcommand;
-use crate::rustc::TargetList;
+use crate::errors::Result;
+use crate::rustc::{ChannelExt, TargetList};
 
+#[derive(Debug)]
 pub struct Args {
     pub all: Vec<String>,
     pub subcommand: Option<Subcommand>,
+    pub channel: Option<Channel>,
     pub target: Option<Target>,
     pub target_dir: Option<PathBuf>,
 }
 
-pub fn parse(target_list: &TargetList) -> Args {
+pub fn parse(target_list: &TargetList) -> Result<Args> {
+    let mut channel = None;
     let mut target = None;
     let mut target_dir = None;
     let mut sc = None;
@@ -20,7 +26,9 @@ pub fn parse(target_list: &TargetList) -> Args {
     {
         let mut args = env::args().skip(1);
         while let Some(arg) = args.next() {
-            if arg == "--target" {
+            if arg.starts_with("+") {
+                channel = Some(Channel::from_str(&arg[1..])?);
+            } else if arg == "--target" {
                 all.push(arg);
                 if let Some(t) = args.next() {
                     target = Some(Target::from(&t, target_list));
@@ -50,10 +58,11 @@ pub fn parse(target_list: &TargetList) -> Args {
         }
     }
 
-    Args {
+    Ok(Args {
         all,
         subcommand: sc,
+        channel,
         target,
         target_dir,
-    }
+    })
 }

src/errors.rs

@@ -7,4 +7,11 @@ error_chain! {
     Io(std::io::Error);
     Which(which::Error);
   }
+
+  errors {
+    InvalidChannelName(channel: String) {
+      description("invalid channel name")
+      display("invalid channel name: '{}'", channel)
+    }
+  }
 }

src/main.rs

@@ -20,7 +20,7 @@ use toml::{Value, value::Table};
 
 use self::cargo::{Root, Subcommand};
 use self::errors::*;
-use self::rustc::{TargetList, VersionMetaExt};
+use self::rustc::{ChannelExt, TargetList, VersionMetaExt};
 
 #[allow(non_camel_case_types)]
 #[derive(Debug, Clone, PartialEq)]
@@ -208,7 +208,7 @@ pub fn main() {
 
 fn run() -> Result<ExitStatus> {
     let target_list = rustc::target_list(false)?;
-    let args = cli::parse(&target_list);
+    let args = cli::parse(&target_list)?;
 
     if args.all.iter().any(|a| a == "--version" || a == "-V") &&
        args.subcommand.is_none() {
@@ -228,9 +228,19 @@ fn run() -> Result<ExitStatus> {
                 .unwrap_or_else(|| Target::from(host.triple(), &target_list));
             let toml = toml(&root)?;
 
-            let sysroot = rustc::sysroot(&host, &target, verbose)?;
-            let toolchain = sysroot.file_name().and_then(|file_name| file_name.to_str())
+            let mut sysroot = rustc::sysroot(&host, &target, verbose)?;
+            let default_toolchain = sysroot.file_name().and_then(|file_name| file_name.to_str())
                 .ok_or("couldn't get toolchain name")?;
+            let toolchain = if let Some(channel) = args.channel {
+                [channel.to_string()].iter().map(|c| c.as_str()).chain(
+                    default_toolchain.splitn(2, '-').skip(1)
+                )
+                    .collect::<Vec<_>>()
+                    .join("-")
+            } else {
+                default_toolchain.to_string()
+            };
+            sysroot.set_file_name(&toolchain);
 
             let installed_toolchains = rustup::installed_toolchains(verbose)?;
 
@@ -250,13 +260,13 @@ fn run() -> Result<ExitStatus> {
 
             if !uses_xargo && !available_targets.is_installed(&target) {
                 rustup::install(&target, &toolchain, verbose)?;
-            } else if !rustup::component_is_installed("rust-src", toolchain, verbose)? {
-                rustup::install_component("rust-src", toolchain, verbose)?;
+            } else if !rustup::component_is_installed("rust-src", &toolchain, verbose)? {
+                rustup::install_component("rust-src", &toolchain, verbose)?;
             }
 
             if args.subcommand.map(|sc| sc == Subcommand::Clippy).unwrap_or(false) &&
-                !rustup::component_is_installed("clippy", toolchain, verbose)? {
-                rustup::install_component("clippy", toolchain, verbose)?;
+                !rustup::component_is_installed("clippy", &toolchain, verbose)? {
+                rustup::install_component("clippy", &toolchain, verbose)?;
             }
 
             let needs_interpreter = args.subcommand.map(|sc| sc.needs_interpreter()).unwrap_or(false);

src/rustc.rs

@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 use std::process::Command;
 
-use rustc_version::{Version, VersionMeta};
+use rustc_version::{Channel, Version, VersionMeta};
 
 use crate::{Host, Target};
 use crate::errors::*;
@@ -38,6 +38,33 @@ impl VersionMetaExt for VersionMeta {
     }
 }
 
+pub(crate) trait ChannelExt {
+    fn from_str(chan: &str) -> Result<Channel>;
+    fn to_string(&self) -> String;
+}
+
+impl ChannelExt for Channel {
+    fn from_str(chan: &str) -> Result<Channel> {
+        Ok(match chan {
+            "stable" => Channel::Stable,
+            "nightly" => Channel::Nightly,
+            "dev" => Channel::Dev,
+            "beta" => Channel::Beta,
+            _ => return Err(
+                ErrorKind::InvalidChannelName(chan.to_string()).into()
+            ),
+        })
+    }
+    fn to_string(&self) -> String {
+        match self {
+            Channel::Stable => "stable",
+            Channel::Nightly => "nightly",
+            Channel::Dev => "dev",
+            Channel::Beta => "beta",
+        }.to_string()
+    }
+}
+
 pub fn target_list(verbose: bool) -> Result<TargetList> {
     Command::new("rustc")
         .args(&["--print", "target-list"])