fix some typos in comments

compiler/rustc_codegen_llvm/src/callee.rs

@@ -93,7 +93,7 @@ pub fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'tcx>) ->
             // To avoid this, we set the Storage Class to "DllImport" so that
             // LLVM will prefix the name with `__imp_`. Ideally, we'd like the
             // existing logic below to set the Storage Class, but it has an
-            // exemption for MinGW for backwards compatability.
+            // exemption for MinGW for backwards compatibility.
             let llfn = cx.declare_fn(&common::i686_decorated_name(&dllimport, common::is_mingw_gnu_toolchain(&tcx.sess.target), true), fn_abi);
             unsafe { llvm::LLVMSetDLLStorageClass(llfn, llvm::DLLStorageClass::DllImport); }
             llfn

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -278,7 +278,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         };
 
         // We could pass the file for long types into these two, but it isn't strictly necessary
-        // given how targetted they are.
+        // given how targeted they are.
         if self.suggest_wrapping_range_with_parens(
             tcx,
             rcvr_ty,

compiler/rustc_mir_transform/src/dest_prop.rs

@@ -83,7 +83,7 @@
 //!   that ever have their address taken. Of course that requires actually having alias analysis
 //!   (and a model to build it on), so this might be a bit of a ways off.
 //!
-//! * Various perf improvents. There are a bunch of comments in here marked `PERF` with ideas for
+//! * Various perf improvements. There are a bunch of comments in here marked `PERF` with ideas for
 //!   how to do things more efficiently. However, the complexity of the pass as a whole should be
 //!   kept in mind.
 //!

compiler/rustc_save_analysis/src/span_utils.rs

@@ -40,7 +40,7 @@ impl<'a> SpanUtils<'a> {
         }
     }
 
-    /// Finds the span of `*` token withing the larger `span`.
+    /// Finds the span of `*` token within the larger `span`.
     pub fn sub_span_of_star(&self, mut span: Span) -> Option<Span> {
         let begin = self.sess.source_map().lookup_byte_offset(span.lo());
         let end = self.sess.source_map().lookup_byte_offset(span.hi());

compiler/rustc_target/src/spec/mod.rs

@@ -122,7 +122,7 @@ pub enum Lld {
 /// target properties, in accordance with the first design goal.
 ///
 /// The first component of the flavor is tightly coupled with the compilation target,
-/// while the `Cc` and `Lld` flags can vary withing the same target.
+/// while the `Cc` and `Lld` flags can vary within the same target.
 #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
 pub enum LinkerFlavor {
     /// Unix-like linker with GNU extensions (both naked and compiler-wrapped forms).

compiler/rustc_trait_selection/src/solve/search_graph/mod.rs

@@ -109,10 +109,10 @@ impl<'tcx> SearchGraph<'tcx> {
     }
 
     /// We cannot simply store the result of [super::EvalCtxt::compute_goal] as we have to deal with
-    /// coinductive cycles.
+    /// continuously cycles.
     ///
-    /// When we encounter a coinductive cycle, we have to prove the final result of that cycle
-    /// while we are still computing that result. Because of this we continously recompute the
+    /// When we encounter a continuously cycle, we have to prove the final result of that cycle
+    /// while we are still computing that result. Because of this we continuously recompute the
     /// cycle until the result of the previous iteration is equal to the final result, at which
     /// point we are done.
     ///
@@ -137,7 +137,7 @@ impl<'tcx> SearchGraph<'tcx> {
         // Was the current goal the root of a cycle and was the provisional response
         // different from the final one.
         if has_been_used && provisional_entry.response != response {
-            // If so, update the provisional reponse for this goal...
+            // If so, update the provisional response for this goal...
             provisional_entry.response = response;
             // ...remove all entries whose result depends on this goal
             // from the provisional cache...

compiler/rustc_trait_selection/src/solve/search_graph/overflow.rs

@@ -44,7 +44,7 @@ impl OverflowData {
     /// Updating the current limit when hitting overflow.
     fn deal_with_overflow(&mut self) {
         // When first hitting overflow we reduce the overflow limit
-        // for all future goals to prevent hangs if there's an exponental
+        // for all future goals to prevent hangs if there's an exponential
         // blowup.
         self.current_limit.0 = self.default_limit.0 / 8;
     }

library/std/src/sys_common/thread_parking/id.rs

@@ -79,7 +79,7 @@ impl Parker {
             park_timeout(dur, self.state.as_mut_ptr().addr());
             // Swap to ensure that we observe all state changes with acquire
             // ordering, even if the state has been changed after the timeout
-            // occured.
+            // occurred.
             self.state.swap(EMPTY, Acquire);
         }
     }

src/tools/clippy/clippy_lints/src/from_over_into.rs

@@ -108,12 +108,12 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
     extract_msrv_attr!(LateContext);
 }
 
-/// Finds the occurences of `Self` and `self`
+/// Finds the occurrences of `Self` and `self`
 struct SelfFinder<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
-    /// Occurences of `Self`
+    /// Occurrences of `Self`
     upper: Vec<Span>,
-    /// Occurences of `self`
+    /// Occurrences of `self`
     lower: Vec<Span>,
     /// If any of the `self`/`Self` usages were from an expansion, or the body contained a binding
     /// already named `val`

src/tools/rust-analyzer/crates/proc-macro-api/src/lib.rs

@@ -70,7 +70,7 @@ impl MacroDylib {
 
 /// A handle to a specific macro (a `#[proc_macro]` annotated function).
 ///
-/// It exists withing a context of a specific [`ProcMacroProcess`] -- currently
+/// It exists within a context of a specific [`ProcMacroProcess`] -- currently
 /// we share a single expander process for all macros.
 #[derive(Debug, Clone)]
 pub struct ProcMacro {

src/tools/rust-analyzer/crates/profile/src/lib.rs

@@ -26,7 +26,7 @@ pub use countme::Count;
 
 thread_local!(static IN_SCOPE: RefCell<bool> = RefCell::new(false));
 
-/// Allows to check if the current code is withing some dynamic scope, can be
+/// Allows to check if the current code is within some dynamic scope, can be
 /// useful during debugging to figure out why a function is called.
 pub struct Scope {
     prev: bool,