Fix some typos

Author: killercup

crates/ra_assists/src/lib.rs

@@ -1,4 +1,4 @@
-//! `ra_assits` crate provides a bunch of code assists, aslo known as code
+//! `ra_assits` crate provides a bunch of code assists, also known as code
 //! actions (in LSP) or intentions (in IntelliJ).
 //!
 //! An assist is a micro-refactoring, which is automatically activated in

crates/ra_assists/src/remove_dbg.rs

@@ -17,9 +17,9 @@ pub(crate) fn remove_dbg(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist>
 
     let macro_range = macro_call.syntax().range();
 
-    // If the cursor is inside the macrocall, we'll try to maintain
-    // the cursor position by subtracting the length of dbg!( from the start
-    // of the filerange, otherwise we'll default to using the start of the macrocall
+    // If the cursor is inside the macro call, we'll try to maintain the cursor
+    // position by subtracting the length of dbg!( from the start of the file
+    // range, otherwise we'll default to using the start of the macro call
     let cursor_pos = {
         let file_range = ctx.frange.range;
 
@@ -61,7 +61,7 @@ fn is_valid_macrocall(macro_call: &ast::MacroCall, macro_name: &str) -> Option<b
     let path = macro_call.path()?;
     let name_ref = path.segment()?.name_ref()?;
 
-    // Make sure it is actually a dbg-macrocall, dbg followed by !
+    // Make sure it is actually a dbg-macro call, dbg followed by !
     let excl = path.syntax().next_sibling()?;
 
     if name_ref.text() != macro_name || excl.kind() != EXCL {

crates/ra_db/src/cancellation.rs

@@ -15,7 +15,7 @@
 //! any background processing (this bit is handled by salsa, see the
 //! `BaseDatabase::check_canceled` method).
 
-/// An "error" signifing that the operation was canceled.
+/// An "error" signifying that the operation was canceled.
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub struct Canceled {
     _private: (),

crates/ra_hir/src/code_model_api.rs

@@ -134,7 +134,7 @@ impl Module {
 
     /// Topmost parent of this module. Every module has a `crate_root`, but some
     /// might be missing `krate`. This can happen if a module's file is not included
-    /// in the module tree of any target in Cargo.toml.
+    /// in the module tree of any target in `Cargo.toml`.
     pub fn crate_root(&self, db: &impl PersistentHirDatabase) -> Module {
         self.crate_root_impl(db)
     }
@@ -351,7 +351,7 @@ impl Enum {
         db.type_for_def((*self).into())
     }
 
-    // TODO move to a more general type
+    // TODO: move to a more general type
     /// Builds a resolver for type references inside this struct.
     pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
         // take the outer scope...
@@ -495,7 +495,7 @@ impl Function {
         db.generic_params((*self).into())
     }
 
-    // TODO move to a more general type for 'body-having' items
+    // TODO: move to a more general type for 'body-having' items
     /// Builds a resolver for code inside this item.
     pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
         // take the outer scope...

crates/ra_hir/src/expr/scope.rs

@@ -84,7 +84,7 @@ impl ExprScopes {
     fn add_bindings(&mut self, body: &Body, scope: ScopeId, pat: PatId) {
         match &body[pat] {
             Pat::Bind { name, .. } => {
-                // bind can have a subpattern, but it's actually not allowed
+                // bind can have a sub pattern, but it's actually not allowed
                 // to bind to things in there
                 let entry = ScopeEntry { name: name.clone(), pat };
                 self.scopes[scope].entries.push(entry)

crates/ra_hir/src/ids.rs

@@ -46,24 +46,24 @@ impl HirInterner {
 /// This module defines a bunch of ids we are using. The most important ones are
 /// probably `HirFileId` and `DefId`.
 
-/// Input to the analyzer is a set of files, where each file is indentified by
+/// Input to the analyzer is a set of files, where each file is identified by
 /// `FileId` and contains source code. However, another source of source code in
 /// Rust are macros: each macro can be thought of as producing a "temporary
 /// file". To assign an id to such a file, we use the id of the macro call that
 /// produced the file. So, a `HirFileId` is either a `FileId` (source code
 /// written by user), or a `MacroCallId` (source code produced by macro).
 ///
-/// What is a `MacroCallId`? Simplifying, it's a `HirFileId` of a file containin
-/// the call plus the offset of the macro call in the file. Note that this is a
-/// recursive definition! However, the size_of of `HirFileId` is finite
-/// (because everything bottoms out at the real `FileId`) and small
+/// What is a `MacroCallId`? Simplifying, it's a `HirFileId` of a file
+/// containing the call plus the offset of the macro call in the file. Note that
+/// this is a recursive definition! However, the size_of of `HirFileId` is
+/// finite (because everything bottoms out at the real `FileId`) and small
 /// (`MacroCallId` uses the location interner).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct HirFileId(HirFileIdRepr);
 
 impl HirFileId {
     /// For macro-expansion files, returns the file original source file the
-    /// expansionoriginated from.
+    /// expansion originated from.
     pub fn original_file(self, db: &impl PersistentHirDatabase) -> FileId {
         match self.0 {
             HirFileIdRepr::File(file_id) => file_id,
@@ -324,9 +324,9 @@ impl SourceFileItems {
 
     fn init(&mut self, source_file: &SourceFile) {
         // By walking the tree in bread-first order we make sure that parents
-        // get lower ids then children. That is, addding a new child does not
+        // get lower ids then children. That is, adding a new child does not
         // change parent's id. This means that, say, adding a new function to a
-        // trait does not chage ids of top-level items, which helps caching.
+        // trait does not change ids of top-level items, which helps caching.
         bfs(source_file.syntax(), |it| {
             if let Some(module_item) = ast::ModuleItem::cast(it) {
                 self.alloc(module_item.syntax());

crates/ra_hir/src/nameres.rs

@@ -490,7 +490,7 @@ impl ItemMap {
                 None => {
                     // we still have path segments left, but the path so far
                     // didn't resolve in the types namespace => no resolution
-                    // (don't break here because curr_per_ns might contain
+                    // (don't break here because `curr_per_ns` might contain
                     // something in the value namespace, and it would be wrong
                     // to return that)
                     return (PerNs::none(), ReachedFixedPoint::No);

crates/ra_hir/src/nameres/lower.rs

@@ -208,7 +208,7 @@ impl LoweredModule {
                 }
             }
             ast::ModuleItemKind::Module(_) => {
-                // modules are handled separately direclty by nameres
+                // modules are handled separately directly by name res
             }
         };
     }

crates/ra_hir/src/path.rs

@@ -97,7 +97,7 @@ impl Path {
                 return Some(q);
             }
             // TODO: this bottom up traversal is not too precise.
-            // Should we handle do a top-down analysiss, recording results?
+            // Should we handle do a top-down analysis, recording results?
             let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?;
             let use_tree = use_tree_list.parent_use_tree();
             use_tree.path()

crates/ra_ide_api/src/completion.rs

@@ -30,7 +30,7 @@ pub use crate::completion::completion_item::{CompletionItem, CompletionItemKind,
 /// incomplete and can look really weird.
 ///
 /// Once the context is collected, we run a series of completion routines which
-/// look at the context and produce completion items. One subtelty about this
+/// look at the context and produce completion items. One subtlety about this
 /// phase is that completion engine should not filter by the substring which is
 /// already present, it should give all possible variants for the identifier at
 /// the caret. In other words, for