Merge #5614

5614: Use split_once polyfill r=matklad a=matklad



bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

crates/ra_project_model/src/cfg_flag.rs

@@ -4,7 +4,7 @@
 use std::str::FromStr;
 
 use ra_cfg::CfgOptions;
-use stdx::split_delim;
+use stdx::split_once;
 
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub enum CfgFlag {
@@ -15,7 +15,7 @@ pub enum CfgFlag {
 impl FromStr for CfgFlag {
     type Err = String;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let res = match split_delim(s, '=') {
+        let res = match split_once(s, '=') {
             Some((key, value)) => {
                 if !(value.starts_with('"') && value.ends_with('"')) {
                     return Err(format!("Invalid cfg ({:?}), value should be in quotes", s));

crates/rust-analyzer/src/bin/args.rs

@@ -8,7 +8,7 @@ use std::{env, fmt::Write, path::PathBuf};
 use anyhow::{bail, Result};
 use pico_args::Arguments;
 use ra_ssr::{SsrPattern, SsrRule};
-use rust_analyzer::cli::{BenchWhat, Position, Verbosity};
+use rust_analyzer::cli::{AnalysisStatsCmd, BenchCmd, BenchWhat, Position, Verbosity};
 use vfs::AbsPathBuf;
 
 pub(crate) struct Args {
@@ -24,23 +24,8 @@ pub(crate) enum Command {
     Highlight {
         rainbow: bool,
     },
-    Stats {
+    AnalysisStats(AnalysisStatsCmd),
-        randomize: bool,
+    Bench(BenchCmd),
-        parallel: bool,
-        memory_usage: bool,
-        only: Option<String>,
-        with_deps: bool,
-        path: PathBuf,
-        load_output_dirs: bool,
-        with_proc_macro: bool,
-    },
-    Bench {
-        memory_usage: bool,
-        path: PathBuf,
-        what: BenchWhat,
-        load_output_dirs: bool,
-        with_proc_macro: bool,
-    },
     Diagnostics {
         path: PathBuf,
         load_output_dirs: bool,
@@ -199,7 +184,7 @@ ARGS:
                     trailing.pop().unwrap().into()
                 };
 
-                Command::Stats {
+                Command::AnalysisStats(AnalysisStatsCmd {
                     randomize,
                     parallel,
                     memory_usage,
@@ -208,7 +193,7 @@ ARGS:
                     path,
                     load_output_dirs,
                     with_proc_macro,
-                }
+                })
             }
             "analysis-bench" => {
                 if matches.contains(["-h", "--help"]) {
@@ -256,7 +241,13 @@ ARGS:
                 let memory_usage = matches.contains("--memory-usage");
                 let load_output_dirs = matches.contains("--load-output-dirs");
                 let with_proc_macro = matches.contains("--with-proc-macro");
-                Command::Bench { memory_usage, path, what, load_output_dirs, with_proc_macro }
+                Command::Bench(BenchCmd {
+                    memory_usage,
+                    path,
+                    what,
+                    load_output_dirs,
+                    with_proc_macro,
+                })
             }
             "diagnostics" => {
                 if matches.contains(["-h", "--help"]) {

crates/rust-analyzer/src/bin/main.rs

@@ -33,36 +33,8 @@ fn main() -> Result<()> {
         args::Command::Parse { no_dump } => cli::parse(no_dump)?,
         args::Command::Symbols => cli::symbols()?,
         args::Command::Highlight { rainbow } => cli::highlight(rainbow)?,
-        args::Command::Stats {
+        args::Command::AnalysisStats(cmd) => cmd.run(args.verbosity)?,
-            randomize,
+        args::Command::Bench(cmd) => cmd.run(args.verbosity)?,
-            parallel,
-            memory_usage,
-            only,
-            with_deps,
-            path,
-            load_output_dirs,
-            with_proc_macro,
-        } => cli::analysis_stats(
-            args.verbosity,
-            memory_usage,
-            path.as_ref(),
-            only.as_ref().map(String::as_ref),
-            with_deps,
-            randomize,
-            parallel,
-            load_output_dirs,
-            with_proc_macro,
-        )?,
-        args::Command::Bench { memory_usage, path, what, load_output_dirs, with_proc_macro } => {
-            cli::analysis_bench(
-                args.verbosity,
-                path.as_ref(),
-                what,
-                memory_usage,
-                load_output_dirs,
-                with_proc_macro,
-            )?
-        }
         args::Command::Diagnostics { path, load_output_dirs, with_proc_macro, all } => {
             cli::diagnostics(path.as_ref(), load_output_dirs, with_proc_macro, all)?
         }

crates/rust-analyzer/src/cli.rs

@@ -14,8 +14,8 @@ use ra_ide::Analysis;
 use ra_prof::profile;
 use ra_syntax::{AstNode, SourceFile};
 
-pub use analysis_bench::{analysis_bench, BenchWhat, Position};
+pub use analysis_bench::{BenchCmd, BenchWhat, Position};
-pub use analysis_stats::analysis_stats;
+pub use analysis_stats::AnalysisStatsCmd;
 pub use diagnostics::diagnostics;
 pub use load_cargo::load_cargo;
 pub use ssr::{apply_ssr_rules, search_for_patterns};

crates/rust-analyzer/src/cli/analysis_bench.rs

@@ -1,8 +1,8 @@
 //! Benchmark operations like highlighting or goto definition.
 
-use std::{env, path::Path, str::FromStr, sync::Arc, time::Instant};
+use std::{env, path::PathBuf, str::FromStr, sync::Arc, time::Instant};
 
-use anyhow::{format_err, Result};
+use anyhow::{bail, format_err, Result};
 use ra_db::{
     salsa::{Database, Durability},
     FileId,
@@ -15,6 +15,14 @@ use crate::{
     print_memory_usage,
 };
 
+pub struct BenchCmd {
+    pub path: PathBuf,
+    pub what: BenchWhat,
+    pub memory_usage: bool,
+    pub load_output_dirs: bool,
+    pub with_proc_macro: bool,
+}
+
 pub enum BenchWhat {
     Highlight { path: AbsPathBuf },
     Complete(Position),
@@ -30,36 +38,29 @@ pub struct Position {
 impl FromStr for Position {
     type Err = anyhow::Error;
     fn from_str(s: &str) -> Result<Self> {
-        let (path_line, column) = rsplit_at_char(s, ':')?;
+        let mut split = s.rsplitn(3, ':');
-        let (path, line) = rsplit_at_char(path_line, ':')?;
+        match (split.next(), split.next(), split.next()) {
+            (Some(column), Some(line), Some(path)) => {
                 let path = env::current_dir().unwrap().join(path);
                 let path = AbsPathBuf::assert(path);
                 Ok(Position { path, line: line.parse()?, column: column.parse()? })
             }
+            _ => bail!("position should be in file:line:column format: {:?}", s),
+        }
+    }
 }
 
-fn rsplit_at_char(s: &str, c: char) -> Result<(&str, &str)> {
+impl BenchCmd {
-    let idx = s.rfind(c).ok_or_else(|| format_err!("no `{}` in {}", c, s))?;
+    pub fn run(self, verbosity: Verbosity) -> Result<()> {
-    Ok((&s[..idx], &s[idx + 1..]))
-}
-
-pub fn analysis_bench(
-    verbosity: Verbosity,
-    path: &Path,
-    what: BenchWhat,
-    memory_usage: bool,
-    load_output_dirs: bool,
-    with_proc_macro: bool,
-) -> Result<()> {
         ra_prof::init();
 
         let start = Instant::now();
         eprint!("loading: ");
-    let (mut host, vfs) = load_cargo(path, load_output_dirs, with_proc_macro)?;
+        let (mut host, vfs) = load_cargo(&self.path, self.load_output_dirs, self.with_proc_macro)?;
         eprintln!("{:?}\n", start.elapsed());
 
         let file_id = {
-        let path = match &what {
+            let path = match &self.what {
                 BenchWhat::Highlight { path } => path,
                 BenchWhat::Complete(pos) | BenchWhat::GotoDef(pos) => &pos.path,
             };
@@ -67,7 +68,7 @@ pub fn analysis_bench(
             vfs.file_id(&path).ok_or_else(|| format_err!("Can't find {}", path))?
         };
 
-    match &what {
+        match &self.what {
             BenchWhat::Highlight { .. } => {
                 let res = do_work(&mut host, file_id, |analysis| {
                     analysis.diagnostics(file_id, true).unwrap();
@@ -78,7 +79,7 @@ pub fn analysis_bench(
                 }
             }
             BenchWhat::Complete(pos) | BenchWhat::GotoDef(pos) => {
-            let is_completion = matches!(what, BenchWhat::Complete(..));
+                let is_completion = matches!(self.what, BenchWhat::Complete(..));
 
                 let offset = host
                     .analysis()
@@ -95,8 +96,9 @@ pub fn analysis_bench(
                         println!("\n{:#?}", res);
                     }
                 } else {
-                let res =
+                    let res = do_work(&mut host, file_id, |analysis| {
-                    do_work(&mut host, file_id, |analysis| analysis.goto_definition(file_position));
+                        analysis.goto_definition(file_position)
+                    });
                     if verbosity.is_verbose() {
                         println!("\n{:#?}", res);
                     }
@@ -104,11 +106,12 @@ pub fn analysis_bench(
             }
         }
 
-    if memory_usage {
+        if self.memory_usage {
             print_memory_usage(host, vfs);
         }
 
         Ok(())
+    }
 }
 
 fn do_work<F: Fn(&Analysis) -> T, T>(host: &mut AnalysisHost, file_id: FileId, work: F) -> T {

crates/rust-analyzer/src/cli/analysis_stats.rs

@@ -2,7 +2,7 @@
 //! errors.
 
 use std::{
-    path::Path,
+    path::PathBuf,
     time::{SystemTime, UNIX_EPOCH},
 };
 
@@ -39,34 +39,36 @@ impl<DB: ParallelDatabase> Clone for Snap<salsa::Snapshot<DB>> {
     }
 }
 
-pub fn analysis_stats(
+pub struct AnalysisStatsCmd {
-    verbosity: Verbosity,
+    pub randomize: bool,
-    memory_usage: bool,
+    pub parallel: bool,
-    path: &Path,
+    pub memory_usage: bool,
-    only: Option<&str>,
+    pub only: Option<String>,
-    with_deps: bool,
+    pub with_deps: bool,
-    randomize: bool,
+    pub path: PathBuf,
-    parallel: bool,
+    pub load_output_dirs: bool,
-    load_output_dirs: bool,
+    pub with_proc_macro: bool,
-    with_proc_macro: bool,
+}
-) -> Result<()> {
+
+impl AnalysisStatsCmd {
+    pub fn run(self, verbosity: Verbosity) -> Result<()> {
         let mut rng = {
             let seed = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis() as u64;
             Rand32::new(seed)
         };
 
-    let mut db_load_sw = StopWatch::start().memory(memory_usage);
+        let mut db_load_sw = self.stop_watch();
-    let (host, vfs) = load_cargo(path, load_output_dirs, with_proc_macro)?;
+        let (host, vfs) = load_cargo(&self.path, self.load_output_dirs, self.with_proc_macro)?;
         let db = host.raw_database();
         eprintln!("Database loaded {}", db_load_sw.elapsed());
 
-    let mut analysis_sw = StopWatch::start().memory(memory_usage);
+        let mut analysis_sw = self.stop_watch();
         let mut num_crates = 0;
         let mut visited_modules = FxHashSet::default();
         let mut visit_queue = Vec::new();
 
         let mut krates = Crate::all(db);
-    if randomize {
+        if self.randomize {
             shuffle(&mut rng, &mut krates);
         }
         for krate in krates {
@@ -75,13 +77,13 @@ pub fn analysis_stats(
             let file_id = file_id.original_file(db);
             let source_root = db.file_source_root(file_id);
             let source_root = db.source_root(source_root);
-        if !source_root.is_library || with_deps {
+            if !source_root.is_library || self.with_deps {
                 num_crates += 1;
                 visit_queue.push(module);
             }
         }
 
-    if randomize {
+        if self.randomize {
             shuffle(&mut rng, &mut visit_queue);
         }
 
@@ -114,18 +116,18 @@ pub fn analysis_stats(
         eprintln!("Total functions: {}", funcs.len());
         eprintln!("Item Collection: {}", analysis_sw.elapsed());
 
-    if randomize {
+        if self.randomize {
             shuffle(&mut rng, &mut funcs);
         }
 
         let mut bar = match verbosity {
             Verbosity::Quiet | Verbosity::Spammy => ProgressReport::hidden(),
-        _ if parallel => ProgressReport::hidden(),
+            _ if self.parallel => ProgressReport::hidden(),
             _ => ProgressReport::new(funcs.len() as u64),
         };
 
-    if parallel {
+        if self.parallel {
-        let mut inference_sw = StopWatch::start().memory(memory_usage);
+            let mut inference_sw = self.stop_watch();
             let snap = Snap(db.snapshot());
             funcs
                 .par_iter()
@@ -138,7 +140,7 @@ pub fn analysis_stats(
             eprintln!("Parallel Inference: {}", inference_sw.elapsed());
         }
 
-    let mut inference_sw = StopWatch::start().memory(memory_usage);
+        let mut inference_sw = self.stop_watch();
         bar.tick();
         let mut num_exprs = 0;
         let mut num_exprs_unknown = 0;
@@ -154,7 +156,7 @@ pub fn analysis_stats(
                 .filter_map(|it| it.name(db))
                 .chain(Some(f.name(db)))
                 .join("::");
-        if let Some(only_name) = only {
+            if let Some(only_name) = self.only.as_deref() {
                 if name.to_string() != only_name && full_name != only_name {
                     continue;
                 }
@@ -192,7 +194,7 @@ pub fn analysis_stats(
                         num_exprs_partially_unknown += 1;
                     }
                 }
-            if only.is_some() && verbosity.is_spammy() {
+                if self.only.is_some() && verbosity.is_spammy() {
                     // in super-verbose mode for just one function, we print every single expression
                     let (_, sm) = db.body_with_source_map(f_id.into());
                     let src = sm.expr_syntax(expr_id);
@@ -301,11 +303,16 @@ pub fn analysis_stats(
             report_metric("total memory", memory.allocated.megabytes() as u64, "MB");
         }
 
-    if memory_usage {
+        if self.memory_usage {
             print_memory_usage(host, vfs);
         }
 
         Ok(())
+    }
+
+    fn stop_watch(&self) -> StopWatch {
+        StopWatch::start().memory(self.memory_usage)
+    }
 }
 
 fn shuffle<T>(rng: &mut Rand32, slice: &mut [T]) {

crates/rust-analyzer/src/handlers.rs

@@ -26,7 +26,7 @@ use ra_project_model::TargetKind;
 use ra_syntax::{algo, ast, AstNode, SyntaxKind, TextRange, TextSize};
 use serde::{Deserialize, Serialize};
 use serde_json::to_value;
-use stdx::{format_to, split_delim};
+use stdx::{format_to, split_once};
 
 use crate::{
     cargo_target_spec::CargoTargetSpec,
@@ -865,7 +865,7 @@ pub(crate) fn handle_resolve_code_action(
         .map(|it| it.into_iter().filter_map(from_proto::assist_kind).collect());
 
     let assists = snap.analysis.resolved_assists(&snap.config.assist, frange)?;
-    let (id_string, index) = split_delim(&params.id, ':').unwrap();
+    let (id_string, index) = split_once(&params.id, ':').unwrap();
     let index = index.parse::<usize>().unwrap();
     let assist = &assists[index];
     assert!(assist.assist.id.0 == id_string);

crates/stdx/src/lib.rs

@@ -109,9 +109,18 @@ pub fn replace(buf: &mut String, from: char, to: &str) {
     *buf = buf.replace(from, to)
 }
 
-pub fn split_delim(haystack: &str, delim: char) -> Option<(&str, &str)> {
+// https://github.com/rust-lang/rust/issues/74773
-    let idx = haystack.find(delim)?;
+pub fn split_once(haystack: &str, delim: char) -> Option<(&str, &str)> {
-    Some((&haystack[..idx], &haystack[idx + delim.len_utf8()..]))
+    let mut split = haystack.splitn(2, delim);
+    let prefix = split.next()?;
+    let suffix = split.next()?;
+    Some((prefix, suffix))
+}
+pub fn rsplit_once(haystack: &str, delim: char) -> Option<(&str, &str)> {
+    let mut split = haystack.rsplitn(2, delim);
+    let suffix = split.next()?;
+    let prefix = split.next()?;
+    Some((prefix, suffix))
 }
 
 pub fn trim_indent(mut text: &str) -> String {

crates/test_utils/src/fixture.rs

@@ -2,7 +2,7 @@
 //! rust-analyzer database from a single string.
 
 use rustc_hash::FxHashMap;
-use stdx::{lines_with_ends, split_delim, trim_indent};
+use stdx::{lines_with_ends, split_once, trim_indent};
 
 #[derive(Debug, Eq, PartialEq)]
 pub struct Fixture {
@@ -71,14 +71,14 @@ impl Fixture {
         let mut cfg_key_values = Vec::new();
         let mut env = FxHashMap::default();
         for component in components[1..].iter() {
-            let (key, value) = split_delim(component, ':').unwrap();
+            let (key, value) = split_once(component, ':').unwrap();
             match key {
                 "crate" => krate = Some(value.to_string()),
                 "deps" => deps = value.split(',').map(|it| it.to_string()).collect(),
                 "edition" => edition = Some(value.to_string()),
                 "cfg" => {
                     for entry in value.split(',') {
-                        match split_delim(entry, '=') {
+                        match split_once(entry, '=') {
                             Some((k, v)) => cfg_key_values.push((k.to_string(), v.to_string())),
                             None => cfg_atoms.push(entry.to_string()),
                         }
@@ -86,7 +86,7 @@ impl Fixture {
                 }
                 "env" => {
                     for key in value.split(',') {
-                        if let Some((k, v)) = split_delim(key, '=') {
+                        if let Some((k, v)) = split_once(key, '=') {
                             env.insert(k.into(), v.into());
                         }
                     }