Ubuntu 21.10 compat

crates/hir-expand/src/builtin_fn_macro.rs

@@ -532,10 +532,10 @@ fn relative_file(
     let path = AnchoredPath { anchor: call_site, path: path_str };
     let res = db
         .resolve_path(path)
-        .ok_or_else(|| ExpandError::Other(format!("failed to load file `{path_str}`").into()))?;
+        .ok_or_else(|| ExpandError::Other(format!("failed to load file `{}`", path_str).into()))?;
     // Prevent include itself
     if res == call_site && !allow_recursion {
-        Err(ExpandError::Other(format!("recursive inclusion of `{path_str}`").into()))
+        Err(ExpandError::Other(format!("recursive inclusion of `{}`", path_str).into()))
     } else {
         Ok(res)
     }

crates/hir-ty/src/display.rs

@@ -1226,7 +1226,7 @@ impl HirDisplay for Path {
                     .as_ref()
                     .map(|name| name.canonical_name())
                     .unwrap_or("$crate");
-                write!(f, "{name}")?
+                write!(f, "{}", name)?
             }
         }
 

crates/ide-assists/src/handlers/convert_let_else_to_match.rs

@@ -147,7 +147,7 @@ pub(crate) fn convert_let_else_to_match(acc: &mut Assists, ctx: &AssistContext)
             // remove the mut from the pattern
             for (b, ismut) in binders.iter() {
                 if *ismut {
-                    pat_no_mut = pat_no_mut.replace(&format!("mut {b}"), &b.to_string());
+                    pat_no_mut = pat_no_mut.replace(&format!("mut {}", b), &b.to_string());
                 }
             }
 
@@ -158,17 +158,17 @@ pub(crate) fn convert_let_else_to_match(acc: &mut Assists, ctx: &AssistContext)
             };
             let replace = if binders.is_empty() {
                 format!(
-                    "match {init_expr} {{
-{indent1}{pat_no_mut} => {binders_str}
-{indent1}_ => {branch2}
-{indent}}}"
+                    "match {} {{
+{}{} => {}
+{}_ => {}
+{}}}", init_expr, indent1, pat_no_mut, binders_str, indent1, branch2, indent
                 )
             } else {
                 format!(
-                    "let {binders_str_mut} = match {init_expr} {{
-{indent1}{pat_no_mut} => {binders_str},
-{indent1}_ => {branch2}
-{indent}}};"
+                    "let {} = match {} {{
+{}{} => {},
+{}_ => {}
+{}}};", binders_str_mut, init_expr, indent1, pat_no_mut, binders_str, indent1, branch2, indent
                 )
             };
             edit.replace(target, replace);

crates/ide-assists/src/handlers/generate_documentation_template.rs

@@ -214,7 +214,7 @@ fn introduction_builder(ast_func: &ast::Fn, ctx: &AssistContext) -> Option<Strin
                 } else {
                     ""
                 };
-                Some(format!("Returns{reference} the {what} of this [`{}`].", linkable_self_ty?))
+                Some(format!("Returns{} the {} of this [`{}`].", reference, what, linkable_self_ty?))
             }
             _ => None,
         };
@@ -228,7 +228,7 @@ fn introduction_builder(ast_func: &ast::Fn, ctx: &AssistContext) -> Option<Strin
             if what == "len" {
                 what = "length".into()
             };
-            Some(format!("Sets the {what} of this [`{}`].", linkable_self_ty?))
+            Some(format!("Sets the {} of this [`{}`].", what, linkable_self_ty?))
         };
 
         if let Some(intro) = intro_for_new() {

crates/ide-completion/src/completions/fn_param.rs

@@ -46,7 +46,7 @@ pub(crate) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
         ParamKind::Closure(closure) => {
             let stmt_list = closure.syntax().ancestors().find_map(ast::StmtList::cast)?;
             params_from_stmt_list_scope(ctx, stmt_list, |name, ty| {
-                add_new_item_to_acc(&format!("{name}: {ty}"));
+                add_new_item_to_acc(&format!("{}: {}", name, ty));
             });
         }
     }
@@ -95,7 +95,7 @@ fn fill_fn_params(
 
     if let Some(stmt_list) = function.syntax().parent().and_then(ast::StmtList::cast) {
         params_from_stmt_list_scope(ctx, stmt_list, |name, ty| {
-            file_params.entry(format!("{name}: {ty}")).or_insert(name.to_string());
+            file_params.entry(format!("{}: {}", name, ty)).or_insert(name.to_string());
         });
     }
     remove_duplicated(&mut file_params, param_list.params());

crates/ide-completion/src/context.rs

@@ -893,7 +893,9 @@ impl<'a> CompletionContext<'a> {
                 it.syntax().text_range().end() == syntax_element.text_range().end()
             });
 
-        (self.expected_type, self.expected_name) = self.expected_type_and_name();
+        let (expected_type, expected_name) = self.expected_type_and_name();
+        self.expected_type = expected_type;
+        self.expected_name = expected_name;
 
         // Overwrite the path kind for derives
         if let Some((original_file, file_with_fake_ident, offset, origin_attr)) = derive_ctx {

crates/ide-db/Cargo.toml

@@ -35,5 +35,5 @@ limit = { path = "../limit", version = "0.0.0" }
 [dev-dependencies]
 test-utils = { path = "../test-utils" }
 sourcegen = { path = "../sourcegen" }
-xshell = "0.2.1"
+xshell = "0.1"
 expect-test = "1.2.2"

crates/ide-db/src/tests/sourcegen_lints.rs

@@ -4,20 +4,16 @@ use std::{borrow::Cow, fs, path::Path};
 use itertools::Itertools;
 use stdx::format_to;
 use test_utils::project_root;
-use xshell::{cmd, Shell};
+use xshell::cmd;
 
 /// This clones rustc repo, and so is not worth to keep up-to-date. We update
 /// manually by un-ignoring the test from time to time.
 #[test]
 #[ignore]
 fn sourcegen_lint_completions() {
-    let sh = &Shell::new().unwrap();
-
     let rust_repo = project_root().join("./target/rust");
     if !rust_repo.exists() {
-        cmd!(sh, "git clone --depth=1 https://github.com/rust-lang/rust {rust_repo}")
-            .run()
-            .unwrap();
+        cmd!("git clone --depth=1 https://github.com/rust-lang/rust {rust_repo}").run().unwrap();
     }
 
     let mut contents = String::from(
@@ -34,19 +30,16 @@ pub struct LintGroup {
 ",
     );
 
-    generate_lint_descriptor(sh, &mut contents);
+    generate_lint_descriptor(&mut contents);
     contents.push('\n');
 
     generate_feature_descriptor(&mut contents, &rust_repo.join("src/doc/unstable-book/src"));
     contents.push('\n');
 
     let lints_json = project_root().join("./target/clippy_lints.json");
-    cmd!(
-        sh,
-        "curl https://rust-lang.github.io/rust-clippy/master/lints.json --output {lints_json}"
-    )
-    .run()
-    .unwrap();
+    cmd!("curl https://rust-lang.github.io/rust-clippy/master/lints.json --output {lints_json}")
+        .run()
+        .unwrap();
     generate_descriptor_clippy(&mut contents, &lints_json);
 
     let contents = sourcegen::add_preamble("sourcegen_lints", sourcegen::reformat(contents));
@@ -55,10 +48,10 @@ pub struct LintGroup {
     sourcegen::ensure_file_contents(destination.as_path(), &contents);
 }
 
-fn generate_lint_descriptor(sh: &Shell, buf: &mut String) {
+fn generate_lint_descriptor(buf: &mut String) {
     // FIXME: rustdoc currently requires an input file for -Whelp cc https://github.com/rust-lang/rust/pull/88831
     let file = project_root().join(file!());
-    let stdout = cmd!(sh, "rustdoc -W help {file}").read().unwrap();
+    let stdout = cmd!("rustdoc -W help {file}").read().unwrap();
     let start_lints = stdout.find("----  -------  -------").unwrap();
     let start_lint_groups = stdout.find("----  ---------").unwrap();
     let start_lints_rustdoc =

crates/ide-diagnostics/src/handlers/unresolved_module.rs

@@ -39,7 +39,7 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::UnresolvedModule) -> Option<Vec<
             .map(|candidate| {
                 fix(
                     "create_module",
-                    &format!("Create module at `{candidate}`"),
+                    &format!("Create module at `{}`", candidate),
                     FileSystemEdit::CreateFile {
                         dst: AnchoredPathBuf {
                             anchor: d.decl.file_id.original_file(ctx.sema.db),

crates/ide/src/doc_links.rs

@@ -424,7 +424,7 @@ fn get_doc_base_url(db: &RootDatabase, def: Definition) -> Option<Url> {
             | LangCrateOrigin::Std
             | LangCrateOrigin::Test),
         ) => {
-            format!("https://doc.rust-lang.org/nightly/{origin}")
+            format!("https://doc.rust-lang.org/nightly/{}", origin)
         }
         _ => {
             krate.get_html_root_url(db).or_else(|| {

crates/ide/src/expand_macro.rs

@@ -168,7 +168,7 @@ fn _format(
         SyntaxKind::MACRO_TYPE => ("type __ =", ";"),
         _ => ("", ""),
     };
-    let expansion = format!("{prefix}{expansion}{suffix}");
+    let expansion = format!("{}{}{}", prefix, expansion, suffix);
 
     let &crate_id = db.relevant_crates(file_id).iter().next()?;
     let edition = db.crate_graph()[crate_id].edition;

crates/ide/src/inlay_hints.rs

@@ -379,7 +379,7 @@ fn fn_lifetime_fn_hints(
     let mut gen_idx_name = {
         let mut gen = (0u8..).map(|idx| match idx {
             idx if idx < 10 => SmolStr::from_iter(['\'', (idx + 48) as char]),
-            idx => format!("'{idx}").into(),
+            idx => format!("'{}", idx).into(),
         });
         move || gen.next().unwrap_or_default()
     };
@@ -412,7 +412,7 @@ fn fn_lifetime_fn_hints(
                 Some(it) if config.param_names_for_lifetime_elision_hints => {
                     if let Some(c) = used_names.get_mut(it.text().as_str()) {
                         *c += 1;
-                        SmolStr::from(format!("'{text}{c}", text = it.text().as_str()))
+                        SmolStr::from(format!("'{text}{c}", text = it.text().as_str(), c=c))
                     } else {
                         used_names.insert(it.text().as_str().into(), 0);
                         SmolStr::from_iter(["\'", it.text().as_str()])

crates/ide/src/moniker.rs

@@ -157,7 +157,7 @@ pub(crate) fn def_to_moniker(
                         LangCrateOrigin::Other => {
                             "https://github.com/rust-lang/rust/library/".into()
                         }
-                        lang => format!("https://github.com/rust-lang/rust/library/{lang}",),
+                        lang => format!("https://github.com/rust-lang/rust/library/{}", lang),
                     },
                 ),
             };

crates/mbe/src/expander/matcher.rs

@@ -658,7 +658,7 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
 fn match_leaf(lhs: &tt::Leaf, src: &mut TtIter) -> Result<(), ExpandError> {
     let rhs = src
         .expect_leaf()
-        .map_err(|()| ExpandError::binding_error(format!("expected leaf: `{lhs}`")))?;
+        .map_err(|()| ExpandError::binding_error(format!("expected leaf: `{}`", lhs)))?;
     match (lhs, rhs) {
         (
             tt::Leaf::Punct(tt::Punct { char: lhs, .. }),

crates/mbe/src/expander/transcriber.rs

@@ -21,28 +21,28 @@ impl Bindings {
         }
 
         let mut b: &Binding =
-            self.inner.get(name).ok_or_else(|| binding_err!("could not find binding `{name}`"))?;
+            self.inner.get(name).ok_or_else(|| binding_err!("could not find binding `{}`", name))?;
         for nesting_state in nesting.iter_mut() {
             nesting_state.hit = true;
             b = match b {
                 Binding::Fragment(_) => break,
                 Binding::Nested(bs) => bs.get(nesting_state.idx).ok_or_else(|| {
                     nesting_state.at_end = true;
-                    binding_err!("could not find nested binding `{name}`")
+                    binding_err!("could not find nested binding `{}`", name)
                 })?,
                 Binding::Empty => {
                     nesting_state.at_end = true;
-                    return Err(binding_err!("could not find empty binding `{name}`"));
+                    return Err(binding_err!("could not find empty binding `{}`", name));
                 }
             };
         }
         match b {
             Binding::Fragment(it) => Ok(it),
             Binding::Nested(_) => {
-                Err(binding_err!("expected simple binding, found nested binding `{name}`"))
+                Err(binding_err!("expected simple binding, found nested binding `{}`", name))
             }
             Binding::Empty => {
-                Err(binding_err!("expected simple binding, found empty binding `{name}`"))
+                Err(binding_err!("expected simple binding, found empty binding `{}`", name))
             }
         }
     }

crates/mbe/src/tt_iter.rs

@@ -106,7 +106,7 @@ impl<'a> TtIter<'a> {
         }
 
         let err = if error || !cursor.is_root() {
-            Some(ExpandError::binding_error(format!("expected {entry_point:?}")))
+            Some(ExpandError::binding_error(format!("expected {:?}", entry_point)))
         } else {
             None
         };

crates/project-model/src/rustc_cfg.rs

@@ -29,7 +29,7 @@ pub(crate) fn get(cargo_toml: Option<&ManifestPath>, target: Option<&str>) -> Ve
             );
             res.extend(rustc_cfgs.lines().filter_map(|it| it.parse().ok()));
         }
-        Err(e) => tracing::error!("failed to get rustc cfgs: {e:?}"),
+        Err(e) => tracing::error!("failed to get rustc cfgs: {:?}", e),
     }
 
     res
@@ -47,7 +47,7 @@ fn get_rust_cfgs(cargo_toml: Option<&ManifestPath>, target: Option<&str>) -> Res
         }
         match utf8_stdout(cargo_config) {
             Ok(it) => return Ok(it),
-            Err(e) => tracing::debug!("{e:?}: falling back to querying rustc for cfgs"),
+            Err(e) => tracing::debug!("{:?}: falling back to querying rustc for cfgs", e),
         }
     }
     // using unstable cargo features failed, fall back to using plain rustc

crates/rust-analyzer/Cargo.toml

@@ -33,7 +33,7 @@ threadpool = "1.8.1"
 rayon = "1.5.1"
 num_cpus = "1.13.1"
 mimalloc = { version = "0.1.28", default-features = false, optional = true }
-lsp-server = { version = "0.6.0", path = "../../lib/lsp-server" }
+lsp-server = "0.5.2"
 tracing = "0.1.32"
 tracing-subscriber = { version = "0.3.9", default-features = false, features = [
     "env-filter",
@@ -75,7 +75,7 @@ jemallocator = { version = "0.4.3", package = "tikv-jemallocator", optional = tr
 [dev-dependencies]
 expect-test = "1.2.2"
 jod-thread = "0.1.2"
-xshell = "0.2.1"
+xshell = "0.1"
 
 test-utils = { path = "../test-utils" }
 sourcegen = { path = "../sourcegen" }

crates/rust-analyzer/src/config.rs

@@ -631,7 +631,7 @@ impl Config {
             ) {
                 Some(snippet) => self.snippets.push(snippet),
                 None => errors.push((
-                    format!("snippet {name} is invalid"),
+                    format!("snippet {} is invalid", name),
                     <serde_json::Error as serde::de::Error>::custom(
                         "snippet path is invalid or triggers are missing",
                     ),

crates/rust-analyzer/src/dispatch.rs

@@ -1,7 +1,6 @@
 //! See [RequestDispatcher].
 use std::{fmt, panic, thread};
 
-use lsp_server::ExtractError;
 use serde::{de::DeserializeOwned, Serialize};
 
 use crate::{
@@ -235,10 +234,7 @@ impl<'a> NotificationDispatcher<'a> {
         };
         let params = match not.extract::<N::Params>(N::METHOD) {
             Ok(it) => it,
-            Err(ExtractError::JsonError { method, error }) => {
-                panic!("Invalid request\nMethod: {method}\n error: {error}",)
-            }
-            Err(ExtractError::MethodMismatch(not)) => {
+            Err(not) => {
                 self.not = Some(not);
                 return Ok(self);
             }

crates/rust-analyzer/src/global_state.rs

@@ -259,11 +259,7 @@ impl GlobalState {
     }
 
     pub(crate) fn complete_request(&mut self, response: lsp_server::Response) {
-        let handler = self
-            .req_queue
-            .outgoing
-            .complete(response.id.clone())
-            .expect("received response for unknown request");
+        let handler = self.req_queue.outgoing.complete(response.id.clone());
         handler(self, response)
     }