rust-analyzer: Fix warnings about clippy str_to_string rule

Author: tetsuharuohzeki

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

@@ -134,7 +134,7 @@ fn setup_logging(log_file_flag: Option<PathBuf>) -> anyhow::Result<()> {
         writer,
         // Deliberately enable all `error` logs if the user has not set RA_LOG, as there is usually
         // useful information in there for debugging.
-        filter: env::var("RA_LOG").ok().unwrap_or_else(|| "error".to_string()),
+        filter: env::var("RA_LOG").ok().unwrap_or_else(|| "error".to_owned()),
         chalk_filter: env::var("CHALK_DEBUG").ok(),
         profile_filter: env::var("RA_PROFILE").ok(),
     }
@@ -224,7 +224,7 @@ fn run_server() -> anyhow::Result<()> {
                 MessageType, ShowMessageParams,
             };
             let not = lsp_server::Notification::new(
-                ShowMessage::METHOD.to_string(),
+                ShowMessage::METHOD.to_owned(),
                 ShowMessageParams { typ: MessageType::WARNING, message: e.to_string() },
             );
             connection.sender.send(lsp_server::Message::Notification(not)).unwrap();

crates/rust-analyzer/src/caps.rs

@@ -44,17 +44,17 @@ pub fn server_capabilities(config: &Config) -> ServerCapabilities {
         completion_provider: Some(CompletionOptions {
             resolve_provider: completions_resolve_provider(config.caps()),
             trigger_characters: Some(vec![
-                ":".to_string(),
-                ".".to_string(),
-                "'".to_string(),
-                "(".to_string(),
+                ":".to_owned(),
+                ".".to_owned(),
+                "'".to_owned(),
+                "(".to_owned(),
             ]),
             all_commit_characters: None,
             completion_item: completion_item(config),
             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
         }),
         signature_help_provider: Some(SignatureHelpOptions {
-            trigger_characters: Some(vec!["(".to_string(), ",".to_string(), "<".to_string()]),
+            trigger_characters: Some(vec!["(".to_owned(), ",".to_owned(), "<".to_owned()]),
             retrigger_characters: None,
             work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
         }),
@@ -74,7 +74,7 @@ pub fn server_capabilities(config: &Config) -> ServerCapabilities {
             _ => Some(OneOf::Left(false)),
         },
         document_on_type_formatting_provider: Some(DocumentOnTypeFormattingOptions {
-            first_trigger_character: "=".to_string(),
+            first_trigger_character: "=".to_owned(),
             more_trigger_character: Some(more_trigger_character(config)),
         }),
         selection_range_provider: Some(SelectionRangeProviderCapability::Simple(true)),
@@ -222,9 +222,9 @@ fn code_action_capabilities(client_caps: &ClientCapabilities) -> CodeActionProvi
 }
 
 fn more_trigger_character(config: &Config) -> Vec<String> {
-    let mut res = vec![".".to_string(), ">".to_string(), "{".to_string(), "(".to_string()];
+    let mut res = vec![".".to_owned(), ">".to_owned(), "{".to_owned(), "(".to_owned()];
     if config.snippet_cap() {
-        res.push("<".to_string());
+        res.push("<".to_owned());
     }
     res
 }

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

@@ -397,7 +397,7 @@ impl flags::AnalysisStats {
                 module
                     .krate()
                     .display_name(db)
-                    .map(|it| it.canonical_name().to_string())
+                    .map(|it| it.canonical_name().to_owned())
                     .into_iter()
                     .chain(
                         module
@@ -688,7 +688,7 @@ impl flags::AnalysisStats {
                 module
                     .krate()
                     .display_name(db)
-                    .map(|it| it.canonical_name().to_string())
+                    .map(|it| it.canonical_name().to_owned())
                     .into_iter()
                     .chain(
                         module
@@ -833,7 +833,7 @@ impl flags::AnalysisStats {
 fn location_csv_expr(db: &RootDatabase, vfs: &Vfs, sm: &BodySourceMap, expr_id: ExprId) -> String {
     let src = match sm.expr_syntax(expr_id) {
         Ok(s) => s,
-        Err(SyntheticSyntax) => return "synthetic,,".to_string(),
+        Err(SyntheticSyntax) => return "synthetic,,".to_owned(),
     };
     let root = db.parse_or_expand(src.file_id);
     let node = src.map(|e| e.to_node(&root).syntax().clone());
@@ -849,7 +849,7 @@ fn location_csv_expr(db: &RootDatabase, vfs: &Vfs, sm: &BodySourceMap, expr_id:
 fn location_csv_pat(db: &RootDatabase, vfs: &Vfs, sm: &BodySourceMap, pat_id: PatId) -> String {
     let src = match sm.pat_syntax(pat_id) {
         Ok(s) => s,
-        Err(SyntheticSyntax) => return "synthetic,,".to_string(),
+        Err(SyntheticSyntax) => return "synthetic,,".to_owned(),
     };
     let root = db.parse_or_expand(src.file_id);
     let node = src.map(|e| e.to_node(&root).syntax().clone());

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

@@ -45,7 +45,7 @@ impl flags::Diagnostics {
             let file_id = module.definition_source_file_id(db).original_file(db);
             if !visited_files.contains(&file_id) {
                 let crate_name =
-                    module.krate().display_name(db).as_deref().unwrap_or("unknown").to_string();
+                    module.krate().display_name(db).as_deref().unwrap_or("unknown").to_owned();
                 println!("processing crate: {crate_name}, module: {}", _vfs.file_path(file_id));
                 for diagnostic in analysis
                     .diagnostics(

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

@@ -104,12 +104,12 @@ impl LsifManager<'_> {
         let result_set_id =
             self.add_vertex(lsif::Vertex::PackageInformation(lsif::PackageInformation {
                 name: pi.name,
-                manager: "cargo".to_string(),
+                manager: "cargo".to_owned(),
                 uri: None,
                 content: None,
                 repository: pi.repo.map(|url| lsif::Repository {
                     url,
-                    r#type: "git".to_string(),
+                    r#type: "git".to_owned(),
                     commit_id: None,
                 }),
                 version: pi.version,
@@ -148,7 +148,7 @@ impl LsifManager<'_> {
         let path = self.vfs.file_path(id);
         let path = path.as_path().unwrap();
         let doc_id = self.add_vertex(lsif::Vertex::Document(lsif::Document {
-            language_id: "rust".to_string(),
+            language_id: "rust".to_owned(),
             uri: lsp_types::Url::from_file_path(path).unwrap(),
         }));
         self.file_map.insert(id, doc_id);
@@ -175,7 +175,7 @@ impl LsifManager<'_> {
         if let Some(moniker) = token.moniker {
             let package_id = self.get_package_id(moniker.package_information);
             let moniker_id = self.add_vertex(lsif::Vertex::Moniker(lsp_types::Moniker {
-                scheme: "rust-analyzer".to_string(),
+                scheme: "rust-analyzer".to_owned(),
                 identifier: moniker.identifier.to_string(),
                 unique: lsp_types::UniquenessLevel::Scheme,
                 kind: Some(match moniker.kind {
@@ -313,7 +313,7 @@ impl flags::Lsif {
             project_root: lsp_types::Url::from_file_path(path).unwrap(),
             position_encoding: lsif::Encoding::Utf16,
             tool_info: Some(lsp_types::lsif::ToolInfo {
-                name: "rust-analyzer".to_string(),
+                name: "rust-analyzer".to_owned(),
                 args: vec![],
                 version: Some(version().to_string()),
             }),

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

@@ -92,7 +92,7 @@ impl<'a> ProgressReport<'a> {
 
         let _ = io::stdout().write(output.as_bytes());
         let _ = io::stdout().flush();
-        self.text = text.to_string();
+        self.text = text.to_owned();
     }
 
     fn set_value(&mut self, value: f32) {

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

@@ -34,7 +34,7 @@ impl flags::RunTests {
             .filter(|x| x.is_test(db));
         let span_formatter = |file_id, text_range: TextRange| {
             let line_col = match db.line_index(file_id).try_line_col(text_range.start()) {
-                None => " (unknown line col)".to_string(),
+                None => " (unknown line col)".to_owned(),
                 Some(x) => format!("#{}:{}", x.line + 1, x.col),
             };
             let path = &db

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

@@ -146,7 +146,7 @@ impl flags::Scip {
                         let signature_documentation =
                             token.signature.clone().map(|text| scip_types::Document {
                                 relative_path: relative_path.clone(),
-                                language: "rust".to_string(),
+                                language: "rust".to_owned(),
                                 text,
                                 position_encoding,
                                 ..Default::default()
@@ -186,7 +186,7 @@ impl flags::Scip {
                 scip_types::PositionEncoding::UTF8CodeUnitOffsetFromLineStart.into();
             documents.push(scip_types::Document {
                 relative_path,
-                language: "rust".to_string(),
+                language: "rust".to_owned(),
                 occurrences,
                 symbols,
                 text: String::new(),
@@ -216,7 +216,7 @@ fn get_relative_filepath(
     rootpath: &vfs::AbsPathBuf,
     file_id: ide::FileId,
 ) -> Option<String> {
-    Some(vfs.file_path(file_id).as_path()?.strip_prefix(rootpath)?.as_ref().to_str()?.to_string())
+    Some(vfs.file_path(file_id).as_path()?.strip_prefix(rootpath)?.as_ref().to_str()?.to_owned())
 }
 
 // SCIP Ranges have a (very large) optimization that ranges if they are on the same line
@@ -239,8 +239,8 @@ fn new_descriptor_str(
     suffix: scip_types::descriptor::Suffix,
 ) -> scip_types::Descriptor {
     scip_types::Descriptor {
-        name: name.to_string(),
-        disambiguator: "".to_string(),
+        name: name.to_owned(),
+        disambiguator: "".to_owned(),
         suffix: suffix.into(),
         special_fields: Default::default(),
     }
@@ -311,9 +311,9 @@ fn moniker_to_symbol(moniker: &MonikerResult) -> scip_types::Symbol {
     scip_types::Symbol {
         scheme: "rust-analyzer".into(),
         package: Some(scip_types::Package {
-            manager: "cargo".to_string(),
+            manager: "cargo".to_owned(),
             name: package_name,
-            version: version.unwrap_or_else(|| ".".to_string()),
+            version: version.unwrap_or_else(|| ".".to_owned()),
             special_fields: Default::default(),
         })
         .into(),

crates/rust-analyzer/src/config.rs

@@ -904,7 +904,7 @@ impl Config {
         use serde::de::Error;
         if self.data.check_command.is_empty() {
             error_sink.push((
-                "/check/command".to_string(),
+                "/check/command".to_owned(),
                 serde_json::Error::custom("expected a non-empty string"),
             ));
         }
@@ -2626,7 +2626,7 @@ mod tests {
             .replace('\n', "\n            ")
             .trim_start_matches('\n')
             .trim_end()
-            .to_string();
+            .to_owned();
         schema.push_str(",\n");
 
         // Transform the asciidoc form link to markdown style.

crates/rust-analyzer/src/config/patch_old_style.rs

@@ -19,7 +19,7 @@ pub(super) fn patch_json_for_outdated_configs(json: &mut Value) {
                 Some(it) => {
                     let mut last = it;
                     for segment in [$(stringify!($dst)),+].into_iter().rev() {
-                        last = Value::Object(serde_json::Map::from_iter(std::iter::once((segment.to_string(), last))));
+                        last = Value::Object(serde_json::Map::from_iter(std::iter::once((segment.to_owned(), last))));
                     }
 
                     merge(json, last);