perf: Use lazy_static with regex

Author: tesuji

src/cli/self_update.rs

@@ -33,7 +33,6 @@
 use crate::common::{self, Confirm};
 use crate::errors::*;
 use crate::term2;
-use regex::Regex;
 use rustup::dist::dist;
 use rustup::utils::utils;
 use rustup::{DUP_TOOLS, TOOLS};
@@ -1378,8 +1377,14 @@ fn get_new_rustup_version(path: &Path) -> Option<String> {
 }
 
 fn parse_new_rustup_version(version: String) -> String {
-    let re = Regex::new(r"\d+.\d+.\d+[0-9a-zA-Z-]*").unwrap();
-    let capture = re.captures(&version);
+    use lazy_static::lazy_static;
+    use regex::Regex;
+
+    lazy_static! {
+        static ref RE: Regex = Regex::new(r"\d+.\d+.\d+[0-9a-zA-Z-]*").unwrap();
+    }
+
+    let capture = RE.captures(&version);
     let matched_version = match capture {
         Some(cap) => cap.get(0).unwrap().as_str(),
         None => "(unknown)",

src/dist/dist.rs

@@ -8,12 +8,13 @@ use crate::dist::temp;
 use crate::errors::*;
 use crate::utils::utils;
 
+use lazy_static::lazy_static;
+use regex::Regex;
+
 use std::env;
 use std::fmt;
 use std::path::Path;
 
-use regex::Regex;
-
 pub const DEFAULT_DIST_SERVER: &str = "https://static.rust-lang.org";
 
 // Deprecated
@@ -223,15 +224,17 @@ impl PartialTargetTriple {
         // we can count  on all triple components being
         // delineated by it.
         let name = format!("-{}", name);
-        let pattern = format!(
-            r"^(?:-({}))?(?:-({}))?(?:-({}))?$",
-            LIST_ARCHS.join("|"),
-            LIST_OSES.join("|"),
-            LIST_ENVS.join("|")
-        );
-
-        let re = Regex::new(&pattern).unwrap();
-        re.captures(&name).map(|c| {
+        lazy_static! {
+            /// This is an example for using doc comment attributes
+            static ref PATTERN: String = format!(
+                r"^(?:-({}))?(?:-({}))?(?:-({}))?$",
+                LIST_ARCHS.join("|"),
+                LIST_OSES.join("|"),
+                LIST_ENVS.join("|")
+            );
+            static ref RE: Regex = Regex::new(&PATTERN).unwrap();
+        }
+        RE.captures(&name).map(|c| {
             fn fn_map(s: &str) -> Option<String> {
                 if s == "" {
                     None
@@ -251,21 +254,22 @@ impl PartialTargetTriple {
 
 impl PartialToolchainDesc {
     pub fn from_str(name: &str) -> Result<Self> {
-        let channels = [
+        const CHANNELS: &[&str] = &[
             "nightly",
             "beta",
             "stable",
             r"\d{1}\.\d{1}\.\d{1}",
             r"\d{1}\.\d{2}\.\d{1}",
         ];
 
-        let pattern = format!(
-            r"^({})(?:-(\d{{4}}-\d{{2}}-\d{{2}}))?(?:-(.*))?$",
-            channels.join("|")
-        );
-
-        let re = Regex::new(&pattern).unwrap();
-        let d = re.captures(name).map(|c| {
+        lazy_static! {
+            static ref PATTERN: String = format!(
+                r"^({})(?:-(\d{{4}}-\d{{2}}-\d{{2}}))?(?:-(.*))?$",
+                CHANNELS.join("|")
+            );
+            static ref RE: Regex = Regex::new(&PATTERN).unwrap();
+        }
+        let d = RE.captures(name).map(|c| {
             fn fn_map(s: &str) -> Option<String> {
                 if s == "" {
                     None
@@ -341,21 +345,23 @@ impl PartialToolchainDesc {
 
 impl ToolchainDesc {
     pub fn from_str(name: &str) -> Result<Self> {
-        let channels = [
+        const CHANNELS: &[&str] = &[
             "nightly",
             "beta",
             "stable",
             r"\d{1}\.\d{1}\.\d{1}",
             r"\d{1}\.\d{2}\.\d{1}",
         ];
 
-        let pattern = format!(
-            r"^({})(?:-(\d{{4}}-\d{{2}}-\d{{2}}))?-(.*)?$",
-            channels.join("|"),
-        );
+        lazy_static! {
+            static ref PATTERN: String = format!(
+                r"^({})(?:-(\d{{4}}-\d{{2}}-\d{{2}}))?-(.*)?$",
+                CHANNELS.join("|"),
+            );
+            static ref RE: Regex = Regex::new(&PATTERN).unwrap();
+        }
 
-        let re = Regex::new(&pattern).unwrap();
-        re.captures(name)
+        RE.captures(name)
             .map(|c| {
                 fn fn_map(s: &str) -> Option<String> {
                     if s == "" {