Use target rather than host toolchain.

Detect if using nightly by using the target rather than the host
toolchain, by checking the channel in `rustup::rustc_version`.

Author: Alexhuszagh

src/main.rs

@@ -21,6 +21,7 @@ use std::path::PathBuf;
 use std::process::ExitStatus;
 
 use config::Config;
+use rustc_version::Channel;
 use serde::Deserialize;
 
 use self::cargo::{Root, Subcommand};
@@ -279,7 +280,6 @@ fn run() -> Result<ExitStatus> {
 
     let host_version_meta =
         rustc_version::version_meta().wrap_err("couldn't fetch the `rustc` version")?;
-    let is_nightly = rustc::is_nightly(&args.channel, &host_version_meta);
     if let Some(root) = cargo::root()? {
         let host = host_version_meta.host();
         let toml = toml(&root)?;
@@ -304,15 +304,17 @@ fn run() -> Result<ExitStatus> {
                 .file_name()
                 .and_then(|file_name| file_name.to_str())
                 .ok_or_else(|| eyre::eyre!("couldn't get toolchain name"))?;
-            let toolchain = if let Some(channel) = args.channel {
-                [channel]
+            let (toolchain, mut is_nightly) = if let Some(channel) = args.channel {
+                let is_nightly = channel.contains("nightly");
+                let toolchain = [channel]
                     .iter()
                     .map(|c| c.as_str())
                     .chain(default_toolchain.splitn(2, '-').skip(1))
                     .collect::<Vec<_>>()
-                    .join("-")
+                    .join("-");
+                (toolchain, is_nightly)
             } else {
-                default_toolchain.to_string()
+                (default_toolchain.to_string(), false)
             };
             sysroot.set_file_name(&toolchain);
 
@@ -322,13 +324,14 @@ fn run() -> Result<ExitStatus> {
                 rustup::install_toolchain(&toolchain, verbose)?;
             }
             // TODO: Provide a way to pick/match the toolchain version as a consumer of `cross`.
-            if let Some((rustc_version, rustc_commit)) = rustup::rustc_version(&sysroot)? {
+            if let Some((rustc_version, channel, rustc_commit)) = rustup::rustc_version(&sysroot)? {
                 warn_host_version_mismatch(
                     &host_version_meta,
                     &toolchain,
                     &rustc_version,
                     &rustc_commit,
                 )?;
+                is_nightly = channel == Channel::Nightly;
             }
 
             let available_targets = rustup::available_targets(&toolchain, verbose)?;

src/rustc.rs

@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 use std::process::Command;
 
-use rustc_version::{Channel, Version, VersionMeta};
+use rustc_version::{Version, VersionMeta};
 
 use crate::errors::*;
 use crate::extensions::CommandExt;
@@ -33,14 +33,6 @@ impl VersionMetaExt for VersionMeta {
     }
 }
 
-pub fn is_nightly(channel: &Option<String>, host_version_meta: &VersionMeta) -> bool {
-    if let Some(channel) = channel {
-        channel.contains("nightly")
-    } else {
-        host_version_meta.channel == Channel::Nightly
-    }
-}
-
 pub fn target_list(verbose: bool) -> Result<TargetList> {
     Command::new("rustc")
         .args(&["--print", "target-list"])

src/rustup.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 use std::process::Command;
 
-use rustc_version::Version;
+use rustc_version::{Channel, Version};
 
 use crate::errors::*;
 use crate::extensions::CommandExt;
@@ -101,7 +101,21 @@ pub fn component_is_installed(component: &str, toolchain: &str, verbose: bool) -
         .any(|l| l.starts_with(component) && l.contains("installed")))
 }
 
-pub fn rustc_version(toolchain_path: &Path) -> Result<Option<(Version, String)>> {
+fn rustc_channel(version: &str) -> Channel {
+    // the channel starts with `"{major}.{minor}.{patch}"`, and can
+    // end also have -beta.{revision} or -nightly after version.
+    if version.contains("dev") {
+        Channel::Dev
+    } else if version.contains("nightly") {
+        Channel::Nightly
+    } else if version.contains("beta") {
+        Channel::Beta
+    } else {
+        Channel::Stable
+    }
+}
+
+pub fn rustc_version(toolchain_path: &Path) -> Result<Option<(Version, Channel, String)>> {
     let path = toolchain_path.join("lib/rustlib/multirust-channel-manifest.toml");
     if path.exists() {
         let contents = std::fs::read(&path)
@@ -119,6 +133,7 @@ pub fn rustc_version(toolchain_path: &Path) -> Result<Option<(Version, String)>>
                     Version::parse(version).wrap_err_with(|| {
                         format!("invalid rust version found in {}", path.display())
                     })?,
+                    rustc_channel(version),
                     meta.to_owned(),
                 )));
             }