Remove a bunch of stray backticks

Thanks VSCode!

Author: estebank

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

@@ -714,7 +714,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     // Errors for `ConstEvaluatable`, `ConstEquate` predicates show up as
                     // `SelectionError::ConstEvalFailure`, not `Unimplemented`.
                     // Ambiguous predicates should never error.
-                    // We never return `Err` when proving `UnstableFeature`` goal.
+                    // We never return `Err` when proving `UnstableFeature` goal.
                     ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(..))
                     | ty::PredicateKind::ConstEquate { .. }
                     | ty::PredicateKind::Ambiguous

src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs

@@ -133,7 +133,7 @@ impl<'tcx> Visitor<'tcx> for NumericFallbackVisitor<'_, 'tcx> {
                 if let Some(fn_sig) = self.cx.tcx.parent_hir_node(expr.hir_id).fn_sig()
                     && let FnRetTy::Return(_ty) = fn_sig.decl.output
                 {
-                    // We cannot check the exact type since it's a `hir::Ty`` which does not implement `is_numeric`
+                    // We cannot check the exact type since it's a `hir::Ty` which does not implement `is_numeric`
                     self.ty_bounds.push(ExplicitTyBound(true));
                     for stmt in *stmts {
                         self.visit_stmt(stmt);

src/tools/miri/src/shims/os_str.rs

@@ -282,7 +282,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     *c = sep;
                 }
             }
-            // If this starts with `//?/`, it was probably produced by `unix_to_windows`` and we
+            // If this starts with `//?/`, it was probably produced by `unix_to_windows` and we
             // remove the `//?` that got added to get the Unix path back out.
             if path.get(0..4) == Some(&[sep, sep, b'?'.into(), sep]) {
                 // Remove first 3 characters. It still starts with `/` so it is absolute on Unix.

src/tools/run-make-support/src/external_deps/rustc.rs

@@ -190,14 +190,14 @@ impl Rustc {
         self
     }
 
-    /// Specify path to the output file. Equivalent to `-o`` in rustc.
+    /// Specify path to the output file. Equivalent to `-o` in rustc.
     pub fn output<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
         self.cmd.arg("-o");
         self.cmd.arg(path.as_ref());
         self
     }
 
-    /// Specify path to the output directory. Equivalent to `--out-dir`` in rustc.
+    /// Specify path to the output directory. Equivalent to `--out-dir` in rustc.
     pub fn out_dir<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
         self.cmd.arg("--out-dir");
         self.cmd.arg(path.as_ref());

src/tools/rust-analyzer/crates/hir-ty/src/traits.rs

@@ -232,11 +232,11 @@ pub fn is_inherent_impl_coherent(db: &dyn HirDatabase, def_map: &DefMap, impl_id
 
 /// Checks whether the impl satisfies the orphan rules.
 ///
-/// Given `impl<P1..=Pn> Trait<T1..=Tn> for T0`, an `impl`` is valid only if at least one of the following is true:
+/// Given `impl<P1..=Pn> Trait<T1..=Tn> for T0`, an `impl` is valid only if at least one of the following is true:
 /// - Trait is a local trait
 /// - All of
-///   - At least one of the types `T0..=Tn`` must be a local type. Let `Ti`` be the first such type.
-///   - No uncovered type parameters `P1..=Pn` may appear in `T0..Ti`` (excluding `Ti`)
+///   - At least one of the types `T0..=Tn` must be a local type. Let `Ti` be the first such type.
+///   - No uncovered type parameters `P1..=Pn` may appear in `T0..Ti` (excluding `Ti`)
 pub fn check_orphan_rules<'db>(db: &'db dyn HirDatabase, impl_: ImplId) -> bool {
     let Some(impl_trait) = db.impl_trait(impl_) else {
         // not a trait impl
@@ -277,10 +277,10 @@ pub fn check_orphan_rules<'db>(db: &'db dyn HirDatabase, impl_: ImplId) -> bool
             }
         }
     };
-    //   - At least one of the types `T0..=Tn`` must be a local type. Let `Ti`` be the first such type.
+    //   - At least one of the types `T0..=Tn` must be a local type. Let `Ti` be the first such type.
 
     // FIXME: param coverage
-    //   - No uncovered type parameters `P1..=Pn` may appear in `T0..Ti`` (excluding `Ti`)
+    //   - No uncovered type parameters `P1..=Pn` may appear in `T0..Ti` (excluding `Ti`)
     let is_not_orphan = trait_ref.args.types().any(|ty| match unwrap_fundamental(ty).kind() {
         TyKind::Adt(adt_def, _) => is_local(adt_def.def_id().module(db).krate(db)),
         TyKind::Error(_) => true,

src/tools/rust-analyzer/crates/mbe/src/parser.rs

@@ -109,7 +109,7 @@ pub(crate) enum Op {
     },
     Count {
         name: Symbol,
-        // FIXME: `usize`` once we drop support for 1.76
+        // FIXME: `usize` once we drop support for 1.76
         depth: Option<usize>,
     },
     Concat {

src/tools/rust-analyzer/crates/project-model/src/workspace.rs

@@ -748,7 +748,7 @@ impl ProjectWorkspace {
                     .packages()
                     .filter_map(|pkg| {
                         if ws[pkg].is_local {
-                            // the local ones are included in the main `PackageRoot`` below
+                            // the local ones are included in the main `PackageRoot` below
                             return None;
                         }
                         let pkg_root = ws[pkg].manifest.parent().to_path_buf();

tests/ui/async-await/async-closures/dont-ice-when-body-tainted-by-errors.rs

@@ -11,7 +11,7 @@ pub fn main() {
         // Type error here taints the environment. This causes us to fallback all
         // variables to `Error`. This means that when we compute the upvars for the
         // *outer* coroutine-closure, we don't actually see any upvars since `MemCategorization`
-        // and `ExprUseVisitor`` will bail early when it sees error. This means
+        // and `ExprUseVisitor` will bail early when it sees error. This means
         // that our underlying assumption that the parent and child captures are
         // compatible ends up being broken, previously leading to an ICE.
         trait_error::<()>();

tests/ui/parser/const-block-items/pub.rs

@@ -2,7 +2,7 @@
 
 //@ check-pass
 
-// FIXME(const_block_items): `pub`` is useless here
+// FIXME(const_block_items): `pub` is useless here
 pub const {
     assert!(true);
 }

tests/ui/parser/raw/raw-idents.rs

@@ -6,7 +6,7 @@
 //@[e2024] edition:2024
 
 // Ensure that all (usable as identifier) keywords work as raw identifiers in all positions.
-// This was motivated by issue #137128, where `r#move`/`r#static`` did not work as `const` names
+// This was motivated by issue #137128, where `r#move`/`r#static` did not work as `const` names
 // due to a parser check not acounting for raw identifiers.
 
 #![crate_type = "lib"]