deps: upgrade to rustwide 0.4.0

Author: pietroalbini

Cargo.lock

@@ -63,7 +63,7 @@ hmac = "0.7"
 sha-1 = "0.8"
 rust_team_data = { git = "https://github.com/rust-lang/team" }
 systemstat = "0.1.4"
-rustwide = { version = "0.3.1", features = ["unstable"] }
+rustwide = { version = "0.4.0", features = ["unstable"] }
 percent-encoding = "2.1.0"
 remove_dir_all = "0.5.2"
 ctrlc = "3.1.3"

Cargo.toml

@@ -63,19 +63,13 @@ pub fn run(
         {
             try_build = Some(build.merge_sha.clone());
             detected_start = Some(Toolchain {
-                source: RustwideToolchain::CI {
-                    sha: build.base_sha.into(),
-                    alt: false,
-                },
+                source: RustwideToolchain::ci(&build.base_sha, false),
                 rustflags: None,
                 ci_try: false,
                 patches: Vec::new(),
             });
             detected_end = Some(Toolchain {
-                source: RustwideToolchain::CI {
-                    sha: build.merge_sha.into(),
-                    alt: false,
-                },
+                source: RustwideToolchain::ci(&build.merge_sha, false),
                 rustflags: None,
                 ci_try: true,
                 patches: Vec::new(),

src/server/routes/webhooks/commands.rs

@@ -1,27 +1,22 @@
 use crate::prelude::*;
 use crate::utils;
 use rustwide::Toolchain as RustwideToolchain;
-use std::borrow::Cow;
 use std::fmt;
 use std::str::FromStr;
 
 #[cfg(test)]
 lazy_static! {
     /// This toolchain is used during internal tests, and must be different than TEST_TOOLCHAIN
     pub(crate) static ref MAIN_TOOLCHAIN: Toolchain = Toolchain {
-        source: RustwideToolchain::Dist {
-            name: Cow::Borrowed("stable"),
-        },
+        source: RustwideToolchain::dist("stable"),
         rustflags: None,
         ci_try: false,
         patches: Vec::new(),
     };
 
     /// This toolchain is used during internal tests, and must be different than MAIN_TOOLCHAIN
     pub(crate) static ref TEST_TOOLCHAIN: Toolchain = Toolchain {
-        source: RustwideToolchain::Dist {
-            name: Cow::Borrowed("beta"),
-        },
+        source: RustwideToolchain::dist("beta"),
         rustflags: None,
         ci_try: false,
         patches: Vec::new(),
@@ -54,17 +49,17 @@ impl std::ops::Deref for Toolchain {
 
 impl fmt::Display for Toolchain {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match &self.source {
-            RustwideToolchain::Dist { name } => write!(f, "{}", name)?,
-            RustwideToolchain::CI { sha, .. } => {
-                if self.ci_try {
-                    write!(f, "try#{}", sha)?;
-                } else {
-                    write!(f, "master#{}", sha)?;
-                }
+        if let Some(dist) = self.source.as_dist() {
+            write!(f, "{}", dist.name())?;
+        } else if let Some(ci) = self.source.as_ci() {
+            if self.ci_try {
+                write!(f, "try#{}", ci.sha())?;
+            } else {
+                write!(f, "master#{}", ci.sha())?;
             }
-            _ => panic!("unsupported rustwide toolchain"),
-        };
+        } else {
+            panic!("unsupported rustwide toolchain");
+        }
 
         if let Some(ref flag) = self.rustflags {
             write!(f, "+rustflags={}", flag)?;
@@ -99,31 +94,23 @@ impl FromStr for Toolchain {
         let source = if let Some(hash_idx) = raw_source.find('#') {
             let (source_name, sha_with_hash) = raw_source.split_at(hash_idx);
 
-            let sha = (&sha_with_hash[1..]).to_string();
+            let sha = &sha_with_hash[1..];
             if sha.is_empty() {
                 return Err(ToolchainParseError::EmptyName);
             }
 
             match source_name {
                 "try" => {
                     ci_try = true;
-                    RustwideToolchain::CI {
-                        sha: Cow::Owned(sha),
-                        alt: false,
-                    }
+                    RustwideToolchain::ci(sha, false)
                 }
-                "master" => RustwideToolchain::CI {
-                    sha: Cow::Owned(sha),
-                    alt: false,
-                },
+                "master" => RustwideToolchain::ci(sha, false),
                 name => return Err(ToolchainParseError::InvalidSourceName(name.to_string())),
             }
         } else if raw_source.is_empty() {
             return Err(ToolchainParseError::EmptyName);
         } else {
-            RustwideToolchain::Dist {
-                name: Cow::Owned(raw_source.to_string()),
-            }
+            RustwideToolchain::dist(raw_source)
         };
 
         let mut rustflags = None;
@@ -254,35 +241,23 @@ mod tests {
         // Test valid reprs
         test_from_str! {
             "stable" => {
-                source:RustwideToolchain::Dist {
-                    name: "stable".into(),
-                },
+                source: RustwideToolchain::dist("stable"),
                 ci_try: false,
             },
             "beta-1970-01-01" => {
-                source: RustwideToolchain::Dist {
-                    name: "beta-1970-01-01".into(),
-                },
+                source: RustwideToolchain::dist("beta-1970-01-01"),
                 ci_try: false,
             },
             "nightly-1970-01-01" => {
-                source: RustwideToolchain::Dist {
-                    name: "nightly-1970-01-01".into(),
-                },
+                source: RustwideToolchain::dist("nightly-1970-01-01"),
                 ci_try: false,
             },
             "master#0000000000000000000000000000000000000000" => {
-                source: RustwideToolchain::CI {
-                    sha: "0000000000000000000000000000000000000000".into(),
-                    alt: false,
-                },
+                source: RustwideToolchain::ci("0000000000000000000000000000000000000000", false),
                 ci_try: false,
             },
             "try#0000000000000000000000000000000000000000" => {
-                source: RustwideToolchain::CI {
-                    sha: "0000000000000000000000000000000000000000".into(),
-                    alt: false,
-                },
+                source: RustwideToolchain::ci("0000000000000000000000000000000000000000", false),
                 ci_try: true,
             },
         };