50 files changed, 1390 insertions, 795 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 54ad92bb1..739edb932 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1125,12 +1125,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "pico-args"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d70072c20945e1ab871c472a285fc772aefd4f5407723c206242f2c6f94595d6"
-
-[[package]]
 name = "pin-project-lite"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1349,7 +1343,6 @@ dependencies = [
  "mimalloc",
  "oorandom",
  "parking_lot",
- "pico-args",
  "proc_macro_srv",
  "profile",
  "project_model",
@@ -1371,6 +1364,7 @@ dependencies = [
  "vfs",
  "vfs-notify",
  "winapi",
+ "xflags",
 ]
 
 [[package]]
@@ -1923,6 +1917,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06069a848f95fceae3e5e03c0ddc8cb78452b56654ee0c8e68f938cf790fb9e3"
 
 [[package]]
+name = "xflags"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddb4b07c0db813f8e2b5e1b2189ef56fcddb27a6f9ef71314dbf8cc50096a5db"
+dependencies = [
+ "xflags-macros",
+]
+
+[[package]]
+name = "xflags-macros"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8e168a99d6ce9d5dd0d0913f1bded279377843952dd8ff83f81b862a1dad0e1"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
 name = "xshell"
 version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1943,11 +1955,11 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "flate2",
- "pico-args",
  "proc-macro2",
  "quote",
  "ungrammar",
  "walkdir",
  "write-json",
+ "xflags",
  "xshell",
 ]
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 00b0dc082..fc1a74641 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -14,7 +14,7 @@ use hir_def::{
     per_ns::PerNs,
     resolver::{HasResolver, Resolver},
     src::HasSource as _,
-    type_ref::{Mutability, TypeRef},
+    type_ref::TypeRef,
     AdtId, AssocContainerId, AssocItemId, AssocItemLoc, AttrDefId, ConstId, ConstParamId,
     DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule, ImplId, LifetimeParamId,
     LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
@@ -32,8 +32,8 @@ use hir_ty::{
     method_resolution,
     traits::{FnTrait, Solution, SolutionVariables},
     AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex, GenericPredicate,
-    InEnvironment, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitEnvironment,
-    Ty, TyDefId, TyVariableKind,
+    InEnvironment, Mutability, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substs,
+    TraitEnvironment, Ty, TyDefId, TyVariableKind,
 };
 use rustc_hash::FxHashSet;
 use stdx::{format_to, impl_from};
@@ -836,7 +836,7 @@ pub enum Access {
 impl From<Mutability> for Access {
     fn from(mutability: Mutability) -> Access {
         match mutability {
-            Mutability::Shared => Access::Shared,
+            Mutability::Not => Access::Shared,
             Mutability::Mut => Access::Exclusive,
         }
     }
@@ -865,7 +865,10 @@ impl SelfParam {
             .params
             .first()
             .map(|param| match *param {
-                TypeRef::Reference(.., mutability) => mutability.into(),
+                TypeRef::Reference(.., mutability) => match mutability {
+                    hir_def::type_ref::Mutability::Shared => Access::Shared,
+                    hir_def::type_ref::Mutability::Mut => Access::Exclusive,
+                },
                 _ => Access::Owned,
             })
             .unwrap_or(Access::Owned)
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index 5e2a711b8..3e19a7702 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -1,5 +1,7 @@
 //! An algorithm to find a path to refer to a certain item.
 
+use std::iter;
+
 use hir_expand::name::{known, AsName, Name};
 use rustc_hash::FxHashSet;
 use test_utils::mark;
@@ -95,7 +97,7 @@ fn find_path_inner(
     item: ItemInNs,
     from: ModuleId,
     max_len: usize,
-    prefixed: Option<PrefixKind>,
+    mut prefixed: Option<PrefixKind>,
 ) -> Option<ModPath> {
     if max_len == 0 {
         return None;
@@ -114,8 +116,9 @@ fn find_path_inner(
     }
 
     // - if the item is the crate root, return `crate`
-    let root = def_map.module_id(def_map.root());
+    let root = def_map.crate_root(db);
     if item == ItemInNs::Types(ModuleDefId::ModuleId(root)) && def_map.block_id().is_none() {
+        // FIXME: the `block_id()` check should be unnecessary, but affects the result
         return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
     }
 
@@ -165,7 +168,7 @@ fn find_path_inner(
 
     // - otherwise, look for modules containing (reexporting) it and import it from one of those
 
-    let crate_root = def_map.module_id(def_map.root());
+    let crate_root = def_map.crate_root(db);
     let crate_attrs = db.attrs(crate_root.into());
     let prefer_no_std = crate_attrs.by_key("no_std").exists();
     let mut best_path = None;
@@ -228,12 +231,16 @@ fn find_path_inner(
         }
     }
 
-    if let Some(mut prefix) = prefixed.map(PrefixKind::prefix) {
-        if matches!(prefix, PathKind::Crate | PathKind::Super(0)) && def_map.block_id().is_some() {
-            // Inner items cannot be referred to via `crate::` or `self::` paths.
-            prefix = PathKind::Plain;
+    // If the item is declared inside a block expression, don't use a prefix, as we don't handle
+    // that correctly (FIXME).
+    if let Some(item_module) = item.as_module_def_id().and_then(|did| did.module(db)) {
+        if item_module.def_map(db).block_id().is_some() && prefixed.is_some() {
+            mark::hit!(prefixed_in_block_expression);
+            prefixed = Some(PrefixKind::Plain);
         }
+    }
 
+    if let Some(prefix) = prefixed.map(PrefixKind::prefix) {
         best_path.or_else(|| {
             scope_name.map(|scope_name| ModPath::from_segments(prefix, vec![scope_name]))
         })
@@ -285,12 +292,12 @@ fn find_local_import_locations(
     let data = &def_map[from.local_id];
     let mut worklist =
         data.children.values().map(|child| def_map.module_id(*child)).collect::<Vec<_>>();
-    let mut parent = data.parent;
-    while let Some(p) = parent {
-        worklist.push(def_map.module_id(p));
-        parent = def_map[p].parent;
+    for ancestor in iter::successors(from.containing_module(db), |m| m.containing_module(db)) {
+        worklist.push(ancestor);
     }
 
+    let def_map = def_map.crate_root(db).def_map(db);
+
     let mut seen: FxHashSet<_> = FxHashSet::default();
 
     let mut locations = Vec::new();
@@ -301,7 +308,14 @@ fn find_local_import_locations(
 
         let ext_def_map;
         let data = if module.krate == from.krate {
-            &def_map[module.local_id]
+            if module.block.is_some() {
+                // Re-query the block's DefMap
+                ext_def_map = module.def_map(db);
+                &ext_def_map[module.local_id]
+            } else {
+                // Reuse the root DefMap
+                &def_map[module.local_id]
+            }
         } else {
             // The crate might reexport a module defined in another crate.
             ext_def_map = module.def_map(db);
@@ -828,6 +842,7 @@ mod tests {
 
     #[test]
     fn inner_items_from_inner_module() {
+        mark::check!(prefixed_in_block_expression);
         check_found_path(
             r#"
             fn main() {
@@ -869,4 +884,24 @@ mod tests {
             "super::Struct",
         );
     }
+
+    #[test]
+    fn outer_items_with_inner_items_present() {
+        check_found_path(
+            r#"
+            mod module {
+                pub struct CompleteMe;
+            }
+
+            fn main() {
+                fn inner() {}
+                $0
+            }
+            "#,
+            "module::CompleteMe",
+            "module::CompleteMe",
+            "crate::module::CompleteMe",
+            "self::module::CompleteMe",
+        )
+    }
 }
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index ee46c3330..4e5daa2ff 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -12,8 +12,8 @@ use stdx::format_to;
 use test_utils::mark;
 
 use crate::{
-    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, HasModule, ImplId,
-    LocalModuleId, Lookup, MacroDefId, ModuleDefId, ModuleId, TraitId,
+    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, ImplId,
+    LocalModuleId, MacroDefId, ModuleDefId, ModuleId, TraitId,
 };
 
 #[derive(Copy, Clone)]
@@ -375,19 +375,9 @@ impl ItemInNs {
 
     /// Returns the crate defining this item (or `None` if `self` is built-in).
     pub fn krate(&self, db: &dyn DefDatabase) -> Option<CrateId> {
-        Some(match self {
-            ItemInNs::Types(did) | ItemInNs::Values(did) => match did {
-                ModuleDefId::ModuleId(id) => id.krate,
-                ModuleDefId::FunctionId(id) => id.lookup(db).module(db).krate,
-                ModuleDefId::AdtId(id) => id.module(db).krate,
-                ModuleDefId::EnumVariantId(id) => id.parent.lookup(db).container.module(db).krate,
-                ModuleDefId::ConstId(id) => id.lookup(db).container.module(db).krate,
-                ModuleDefId::StaticId(id) => id.lookup(db).container.module(db).krate,
-                ModuleDefId::TraitId(id) => id.lookup(db).container.module(db).krate,
-                ModuleDefId::TypeAliasId(id) => id.lookup(db).module(db).krate,
-                ModuleDefId::BuiltinType(_) => return None,
-            },
-            ItemInNs::Macros(id) => return Some(id.krate),
-        })
+        match self {
+            ItemInNs::Types(did) | ItemInNs::Values(did) => did.module(db).map(|m| m.krate),
+            ItemInNs::Macros(id) => Some(id.krate),
+        }
     }
 }
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index 6802bc250..4498d94bb 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -97,6 +97,10 @@ impl ModuleId {
     pub fn krate(&self) -> CrateId {
         self.krate
     }
+
+    pub fn containing_module(&self, db: &dyn db::DefDatabase) -> Option<ModuleId> {
+        self.def_map(db).containing_module(self.local_id)
+    }
 }
 
 /// An ID of a module, **local** to a specific crate
@@ -529,6 +533,25 @@ impl HasModule for StaticLoc {
     }
 }
 
+impl ModuleDefId {
+    /// Returns the module containing `self` (or `self`, if `self` is itself a module).
+    ///
+    /// Returns `None` if `self` refers to a primitive type.
+    pub fn module(&self, db: &dyn db::DefDatabase) -> Option<ModuleId> {
+        Some(match self {
+            ModuleDefId::ModuleId(id) => *id,
+            ModuleDefId::FunctionId(id) => id.lookup(db).module(db),
+            ModuleDefId::AdtId(id) => id.module(db),
+            ModuleDefId::EnumVariantId(id) => id.parent.lookup(db).container.module(db),
+            ModuleDefId::ConstId(id) => id.lookup(db).container.module(db),
+            ModuleDefId::StaticId(id) => id.lookup(db).container.module(db),
+            ModuleDefId::TraitId(id) => id.lookup(db).container.module(db),
+            ModuleDefId::TypeAliasId(id) => id.lookup(db).module(db),
+            ModuleDefId::BuiltinType(_) => return None,
+        })
+    }
+}
+
 impl AttrDefId {
     pub fn krate(&self, db: &dyn db::DefDatabase) -> CrateId {
         match self {
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 6a3456f2e..003d668ca 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -343,6 +343,18 @@ impl DefMap {
         Some(self.block?.parent)
     }
 
+    /// Returns the module containing `local_mod`, either the parent `mod`, or the module containing
+    /// the block, if `self` corresponds to a block expression.
+    pub fn containing_module(&self, local_mod: LocalModuleId) -> Option<ModuleId> {
+        match &self[local_mod].parent {
+            Some(parent) => Some(self.module_id(*parent)),
+            None => match &self.block {
+                Some(block) => Some(block.parent),
+                None => None,
+            },
+        }
+    }
+
     // FIXME: this can use some more human-readable format (ideally, an IR
     // even), as this should be a great debugging aid.
     pub fn dump(&self, db: &dyn DefDatabase) -> String {
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index f3a4333cb..d4a8b48e6 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -8,6 +8,7 @@ use crate::{
     TraitRef, Ty,
 };
 use arrayvec::ArrayVec;
+use chalk_ir::Mutability;
 use hir_def::{
     db::DefDatabase, find_path, generics::TypeParamProvenance, item_scope::ItemInNs, AdtId,
     AssocContainerId, HasModule, Lookup, ModuleId, TraitId,
@@ -291,9 +292,23 @@ impl HirDisplay for Ty {
                     t.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);
 
                 if matches!(self, Ty::Raw(..)) {
-                    write!(f, "*{}", m.as_keyword_for_ptr())?;
+                    write!(
+                        f,
+                        "*{}",
+                        match m {
+                            Mutability::Not => "const ",
+                            Mutability::Mut => "mut ",
+                        }
+                    )?;
                 } else {
-                    write!(f, "&{}", m.as_keyword_for_ref())?;
+                    write!(
+                        f,
+                        "&{}",
+                        match m {
+                            Mutability::Not => "",
+                            Mutability::Mut => "mut ",
+                        }
+                    )?;
                 }
 
                 let datas;
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 18a4f5e8a..4d771a91e 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -18,6 +18,7 @@ use std::mem;
 use std::ops::Index;
 use std::sync::Arc;
 
+use chalk_ir::Mutability;
 use hir_def::{
     body::Body,
     data::{ConstData, FunctionData, StaticData},
@@ -25,7 +26,7 @@ use hir_def::{
     lang_item::LangItemTarget,
     path::{path, Path},
     resolver::{HasResolver, Resolver, TypeNs},
-    type_ref::{Mutability, TypeRef},
+    type_ref::TypeRef,
     AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, FunctionId, Lookup, TraitId,
     TypeAliasId, VariantId,
 };
@@ -87,7 +88,7 @@ impl BindingMode {
     fn convert(annotation: BindingAnnotation) -> BindingMode {
         match annotation {
             BindingAnnotation::Unannotated | BindingAnnotation::Mutable => BindingMode::Move,
-            BindingAnnotation::Ref => BindingMode::Ref(Mutability::Shared),
+            BindingAnnotation::Ref => BindingMode::Ref(Mutability::Not),
             BindingAnnotation::RefMut => BindingMode::Ref(Mutability::Mut),
         }
     }
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index c33d8c61e..cf0a3add4 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -4,8 +4,8 @@
 //!
 //! See: https://doc.rust-lang.org/nomicon/coercions.html
 
-use chalk_ir::TyVariableKind;
-use hir_def::{lang_item::LangItemTarget, type_ref::Mutability};
+use chalk_ir::{Mutability, TyVariableKind};
+use hir_def::lang_item::LangItemTarget;
 use test_utils::mark;
 
 use crate::{autoderef, traits::Solution, Obligation, Substs, TraitRef, Ty};
@@ -73,20 +73,20 @@ impl<'a> InferenceContext<'a> {
         match (&mut from_ty, to_ty) {
             // `*mut T` -> `*const T`
             // `&mut T` -> `&T`
-            (Ty::Raw(m1, ..), Ty::Raw(m2 @ Mutability::Shared, ..))
-            | (Ty::Ref(m1, ..), Ty::Ref(m2 @ Mutability::Shared, ..)) => {
+            (Ty::Raw(m1, ..), Ty::Raw(m2 @ Mutability::Not, ..))
+            | (Ty::Ref(m1, ..), Ty::Ref(m2 @ Mutability::Not, ..)) => {
                 *m1 = *m2;
             }
             // `&T` -> `*const T`
             // `&mut T` -> `*mut T`/`*const T`
-            (Ty::Ref(.., substs), &Ty::Raw(m2 @ Mutability::Shared, ..))
+            (Ty::Ref(.., substs), &Ty::Raw(m2 @ Mutability::Not, ..))
             | (Ty::Ref(Mutability::Mut, substs), &Ty::Raw(m2, ..)) => {
                 from_ty = Ty::Raw(m2, substs.clone());
             }
 
             // Illegal mutability conversion
-            (Ty::Raw(Mutability::Shared, ..), Ty::Raw(Mutability::Mut, ..))
-            | (Ty::Ref(Mutability::Shared, ..), Ty::Ref(Mutability::Mut, ..)) => return false,
+            (Ty::Raw(Mutability::Not, ..), Ty::Raw(Mutability::Mut, ..))
+            | (Ty::Ref(Mutability::Not, ..), Ty::Ref(Mutability::Mut, ..)) => return false,
 
             // `{function_type}` -> `fn()`
             (Ty::FnDef(..), Ty::Function { .. }) => match from_ty.callable_sig(self.db) {
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 7852b3d23..cf1f1038a 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -3,7 +3,7 @@
 use std::iter::{repeat, repeat_with};
 use std::{mem, sync::Arc};
 
-use chalk_ir::TyVariableKind;
+use chalk_ir::{Mutability, TyVariableKind};
 use hir_def::{
     expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
     path::{GenericArg, GenericArgs},
@@ -15,12 +15,14 @@ use syntax::ast::RangeOp;
 use test_utils::mark;
 
 use crate::{
-    autoderef, method_resolution, op,
+    autoderef,
+    lower::lower_to_chalk_mutability,
+    method_resolution, op,
     primitive::{self, UintTy},
     traits::{FnTrait, InEnvironment},
     utils::{generics, variant_data, Generics},
-    Binders, CallableDefId, FnPointer, FnSig, Mutability, Obligation, OpaqueTyId, Rawness, Scalar,
-    Substs, TraitRef, Ty,
+    Binders, CallableDefId, FnPointer, FnSig, Obligation, OpaqueTyId, Rawness, Scalar, Substs,
+    TraitRef, Ty,
 };
 
 use super::{
@@ -462,10 +464,11 @@ impl<'a> InferenceContext<'a> {
                 cast_ty
             }
             Expr::Ref { expr, rawness, mutability } => {
+                let mutability = lower_to_chalk_mutability(*mutability);
                 let expectation = if let Some((exp_inner, exp_rawness, exp_mutability)) =
                     &expected.ty.as_reference_or_ptr()
                 {
-                    if *exp_mutability == Mutability::Mut && *mutability == Mutability::Shared {
+                    if *exp_mutability == Mutability::Mut && mutability == Mutability::Not {
                         // FIXME: throw type error - expected mut reference but found shared ref,
                         // which cannot be coerced
                     }
@@ -479,8 +482,8 @@ impl<'a> InferenceContext<'a> {
                 };
                 let inner_ty = self.infer_expr_inner(*expr, &expectation);
                 match rawness {
-                    Rawness::RawPtr => Ty::Raw(*mutability, Substs::single(inner_ty)),
-                    Rawness::Ref => Ty::Ref(*mutability, Substs::single(inner_ty)),
+                    Rawness::RawPtr => Ty::Raw(mutability, Substs::single(inner_ty)),
+                    Rawness::Ref => Ty::Ref(mutability, Substs::single(inner_ty)),
                 }
             }
             Expr::Box { expr } => {
@@ -684,11 +687,11 @@ impl<'a> InferenceContext<'a> {
             }
             Expr::Literal(lit) => match lit {
                 Literal::Bool(..) => Ty::Scalar(Scalar::Bool),
-                Literal::String(..) => Ty::Ref(Mutability::Shared, Substs::single(Ty::Str)),
+                Literal::String(..) => Ty::Ref(Mutability::Not, Substs::single(Ty::Str)),
                 Literal::ByteString(..) => {
                     let byte_type = Ty::Scalar(Scalar::Uint(UintTy::U8));
                     let array_type = Ty::Array(Substs::single(byte_type));
-                    Ty::Ref(Mutability::Shared, Substs::single(array_type))
+                    Ty::Ref(Mutability::Not, Substs::single(array_type))
                 }
                 Literal::Char(..) => Ty::Scalar(Scalar::Char),
                 Literal::Int(_v, ty) => match ty {
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index a318e47f3..eb099311c 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -3,17 +3,17 @@
 use std::iter::repeat;
 use std::sync::Arc;
 
+use chalk_ir::Mutability;
 use hir_def::{
     expr::{BindingAnnotation, Expr, Literal, Pat, PatId, RecordFieldPat},
     path::Path,
-    type_ref::Mutability,
     FieldId,
 };
 use hir_expand::name::Name;
 use test_utils::mark;
 
 use super::{BindingMode, Expectation, InferenceContext};
-use crate::{utils::variant_data, Substs, Ty};
+use crate::{lower::lower_to_chalk_mutability, utils::variant_data, Substs, Ty};
 
 impl<'a> InferenceContext<'a> {
     fn infer_tuple_struct_pat(
@@ -103,7 +103,7 @@ impl<'a> InferenceContext<'a> {
                 expected = inner;
                 default_bm = match default_bm {
                     BindingMode::Move => BindingMode::Ref(mutability),
-                    BindingMode::Ref(Mutability::Shared) => BindingMode::Ref(Mutability::Shared),
+                    BindingMode::Ref(Mutability::Not) => BindingMode::Ref(Mutability::Not),
                     BindingMode::Ref(Mutability::Mut) => BindingMode::Ref(mutability),
                 }
             }
@@ -152,9 +152,10 @@ impl<'a> InferenceContext<'a> {
                 }
             }
             Pat::Ref { pat, mutability } => {
+                let mutability = lower_to_chalk_mutability(*mutability);
                 let expectation = match expected.as_reference() {
                     Some((inner_ty, exp_mut)) => {
-                        if *mutability != exp_mut {
+                        if mutability != exp_mut {
                             // FIXME: emit type error?
                         }
                         inner_ty
@@ -162,7 +163,7 @@ impl<'a> InferenceContext<'a> {
                     _ => &Ty::Unknown,
                 };
                 let subty = self.infer_pat(*pat, expectation, default_bm);
-                Ty::Ref(*mutability, Substs::single(subty))
+                Ty::Ref(mutability, Substs::single(subty))
             }
             Pat::TupleStruct { path: p, args: subpats, ellipsis } => self.infer_tuple_struct_pat(
                 p.as_ref(),
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 9bcaf6fa7..c2a20c480 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -27,11 +27,9 @@ use std::{iter, mem, ops::Deref, sync::Arc};
 
 use base_db::salsa;
 use hir_def::{
-    builtin_type::BuiltinType,
-    expr::ExprId,
-    type_ref::{Mutability, Rawness},
-    AdtId, AssocContainerId, DefWithBodyId, FunctionId, GenericDefId, HasModule, LifetimeParamId,
-    Lookup, TraitId, TypeAliasId, TypeParamId,
+    builtin_type::BuiltinType, expr::ExprId, type_ref::Rawness, AdtId, AssocContainerId,
+    DefWithBodyId, FunctionId, GenericDefId, HasModule, LifetimeParamId, Lookup, TraitId,
+    TypeAliasId, TypeParamId,
 };
 use itertools::Itertools;
 
@@ -49,7 +47,7 @@ pub use lower::{
 };
 pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
 
-pub use chalk_ir::{BoundVar, DebruijnIndex, Scalar, TyVariableKind};
+pub use chalk_ir::{BoundVar, DebruijnIndex, Mutability, Scalar, TyVariableKind};
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum Lifetime {
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index ca06c9fe2..1b5843d48 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -8,6 +8,7 @@
 use std::{iter, sync::Arc};
 
 use base_db::CrateId;
+use chalk_ir::Mutability;
 use hir_def::{
     adt::StructKind,
     builtin_type::BuiltinType,
@@ -157,7 +158,7 @@ impl Ty {
             }
             TypeRef::RawPtr(inner, mutability) => {
                 let inner_ty = Ty::from_hir(ctx, inner);
-                Ty::Raw(*mutability, Substs::single(inner_ty))
+                Ty::Raw(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty))
             }
             TypeRef::Array(inner) => {
                 let inner_ty = Ty::from_hir(ctx, inner);
@@ -169,7 +170,7 @@ impl Ty {
             }
             TypeRef::Reference(inner, _, mutability) => {
                 let inner_ty = Ty::from_hir(ctx, inner);
-                Ty::Ref(*mutability, Substs::single(inner_ty))
+                Ty::Ref(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty))
             }
             TypeRef::Placeholder => Ty::Unknown,
             TypeRef::Fn(params, is_varargs) => {
@@ -1259,3 +1260,10 @@ pub(crate) fn return_type_impl_traits(
         Some(Arc::new(Binders::new(num_binders, return_type_impl_traits)))
     }
 }
+
+pub(crate) fn lower_to_chalk_mutability(m: hir_def::type_ref::Mutability) -> Mutability {
+    match m {
+        hir_def::type_ref::Mutability::Shared => Mutability::Not,
+        hir_def::type_ref::Mutability::Mut => Mutability::Mut,
+    }
+}
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index dd5109d4e..f301a8477 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -6,9 +6,10 @@ use std::{iter, sync::Arc};
 
 use arrayvec::ArrayVec;
 use base_db::CrateId;
+use chalk_ir::Mutability;
 use hir_def::{
-    lang_item::LangItemTarget, type_ref::Mutability, AdtId, AssocContainerId, AssocItemId,
-    FunctionId, GenericDefId, HasModule, ImplId, Lookup, ModuleId, TraitId, TypeAliasId,
+    lang_item::LangItemTarget, AdtId, AssocContainerId, AssocItemId, FunctionId, GenericDefId,
+    HasModule, ImplId, Lookup, ModuleId, TraitId, TypeAliasId,
 };
 use hir_expand::name::Name;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -251,7 +252,7 @@ impl Ty {
             }
             Ty::Str => lang_item_crate!("str_alloc", "str"),
             Ty::Slice(_) => lang_item_crate!("slice_alloc", "slice"),
-            Ty::Raw(Mutability::Shared, _) => lang_item_crate!("const_ptr"),
+            Ty::Raw(Mutability::Not, _) => lang_item_crate!("const_ptr"),
             Ty::Raw(Mutability::Mut, _) => lang_item_crate!("mut_ptr"),
             Ty::Dyn(_) => {
                 return self.dyn_trait().and_then(|trait_| {
@@ -429,7 +430,7 @@ fn iterate_method_candidates_with_autoref(
     }
     let refed = Canonical {
         kinds: deref_chain[0].kinds.clone(),
-        value: Ty::Ref(Mutability::Shared, Substs::single(deref_chain[0].value.clone())),
+        value: Ty::Ref(Mutability::Not, Substs::single(deref_chain[0].value.clone())),
     };
     if iterate_method_candidates_by_receiver(
         &refed,
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index 6e6055d80..db1760e6c 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -10,7 +10,7 @@ use chalk_ir::{
 use chalk_solve::rust_ir;
 
 use base_db::salsa::InternKey;
-use hir_def::{type_ref::Mutability, AssocContainerId, GenericDefId, Lookup, TypeAliasId};
+use hir_def::{AssocContainerId, GenericDefId, Lookup, TypeAliasId};
 
 use crate::{
     db::HirDatabase,
@@ -65,7 +65,7 @@ impl ToChalk for Ty {
             }
             Ty::Raw(mutability, substs) => {
                 let ty = substs[0].clone().to_chalk(db);
-                chalk_ir::TyKind::Raw(mutability.to_chalk(db), ty).intern(&Interner)
+                chalk_ir::TyKind::Raw(mutability, ty).intern(&Interner)
             }
             Ty::Slice(substs) => {
                 chalk_ir::TyKind::Slice(substs[0].clone().to_chalk(db)).intern(&Interner)
@@ -198,11 +198,11 @@ impl ToChalk for Ty {
                 Ty::Tuple(cardinality, from_chalk(db, subst))
             }
             chalk_ir::TyKind::Raw(mutability, ty) => {
-                Ty::Raw(from_chalk(db, mutability), Substs::single(from_chalk(db, ty)))
+                Ty::Raw(mutability, Substs::single(from_chalk(db, ty)))
             }
             chalk_ir::TyKind::Slice(ty) => Ty::Slice(Substs::single(from_chalk(db, ty))),
             chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => {
-                Ty::Ref(from_chalk(db, mutability), Substs::single(from_chalk(db, ty)))
+                Ty::Ref(mutability, Substs::single(from_chalk(db, ty)))
             }
             chalk_ir::TyKind::Str => Ty::Str,
             chalk_ir::TyKind::Never => Ty::Never,
@@ -230,12 +230,12 @@ impl ToChalk for Ty {
 /// fake lifetime here, because Chalks built-in logic may expect it to be there.
 fn ref_to_chalk(
     db: &dyn HirDatabase,
-    mutability: Mutability,
+    mutability: chalk_ir::Mutability,
     subst: Substs,
 ) -> chalk_ir::Ty<Interner> {
     let arg = subst[0].clone().to_chalk(db);
     let lifetime = LifetimeData::Static.intern(&Interner);
-    chalk_ir::TyKind::Ref(mutability.to_chalk(db), lifetime, arg).intern(&Interner)
+    chalk_ir::TyKind::Ref(mutability, lifetime, arg).intern(&Interner)
 }
 
 /// We currently don't model constants, but Chalk does. So, we have to insert a
@@ -313,22 +313,6 @@ impl ToChalk for OpaqueTyId {
     }
 }
 
-impl ToChalk for Mutability {
-    type Chalk = chalk_ir::Mutability;
-    fn to_chalk(self, _db: &dyn HirDatabase) -> Self::Chalk {
-        match self {
-            Mutability::Shared => chalk_ir::Mutability::Not,
-            Mutability::Mut => chalk_ir::Mutability::Mut,
-        }
-    }
-    fn from_chalk(_db: &dyn HirDatabase, chalk: Self::Chalk) -> Self {
-        match chalk {
-            chalk_ir::Mutability::Mut => Mutability::Mut,
-            chalk_ir::Mutability::Not => Mutability::Shared,
-        }
-    }
-}
-
 impl ToChalk for hir_def::ImplId {
     type Chalk = ImplId;
 
diff --git a/crates/ide_assists/src/handlers/convert_comment_block.rs b/crates/ide_assists/src/handlers/convert_comment_block.rs
new file mode 100644
index 000000000..cdc45fc42
--- /dev/null
+++ b/crates/ide_assists/src/handlers/convert_comment_block.rs
@@ -0,0 +1,419 @@
+use itertools::Itertools;
+use std::convert::identity;
+use syntax::{
+    ast::{
+        self,
+        edit::IndentLevel,
+        Comment, CommentKind,
+        CommentPlacement::{Inner, Outer},
+        CommentShape::{self, Block, Line},
+        Whitespace,
+    },
+    AstToken, Direction, SyntaxElement, TextRange,
+};
+
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+
+/// Assist: line_to_block
+///
+/// Converts comments between block and single-line form
+///
+/// ```
+///    // Multi-line
+///    // comment
+/// ```
+/// ->
+/// ```
+///   /**
+///   Multi-line
+///   comment
+///   */
+/// ```
+pub(crate) fn convert_comment_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    if let Some(comment) = ctx.find_token_at_offset::<ast::Comment>() {
+        // Only allow comments which are alone on their line
+        if let Some(prev) = comment.syntax().prev_token() {
+            if Whitespace::cast(prev).filter(|w| w.text().contains('\n')).is_none() {
+                return None;
+            }
+        }
+
+        return match comment.kind().shape {
+            ast::CommentShape::Block => block_to_line(acc, comment),
+            ast::CommentShape::Line => line_to_block(acc, comment),
+        };
+    }
+
+    return None;
+}
+
+fn block_to_line(acc: &mut Assists, comment: ast::Comment) -> Option<()> {
+    let target = comment.syntax().text_range();
+
+    acc.add(
+        AssistId("block_to_line", AssistKind::RefactorRewrite),
+        "Replace block comment with line comments",
+        target,
+        |edit| {
+            let indentation = IndentLevel::from_token(comment.syntax());
+            let line_prefix =
+                comment_kind_prefix(CommentKind { shape: CommentShape::Line, ..comment.kind() });
+
+            let text = comment.text();
+            let text = &text[comment.prefix().len()..(text.len() - "*/".len())].trim();
+
+            let lines = text.lines().peekable();
+
+            let indent_spaces = indentation.to_string();
+            let output = lines
+                .map(|l| l.trim_start_matches(&indent_spaces))
+                .map(|l| {
+                    // Don't introduce trailing whitespace
+                    if l.is_empty() {
+                        line_prefix.to_string()
+                    } else {
+                        format!("{} {}", line_prefix, l.trim_start_matches(&indent_spaces))
+                    }
+                })
+                .join(&format!("\n{}", indent_spaces));
+
+            edit.replace(target, output)
+        },
+    )
+}
+
+fn line_to_block(acc: &mut Assists, comment: ast::Comment) -> Option<()> {
+    // Find all the comments we'll be collapsing into a block
+    let comments = relevant_line_comments(&comment);
+
+    // Establish the target of our edit based on the comments we found
+    let target = TextRange::new(
+        comments[0].syntax().text_range().start(),
+        comments.last().unwrap().syntax().text_range().end(),
+    );
+
+    acc.add(
+        AssistId("line_to_block", AssistKind::RefactorRewrite),
+        "Replace line comments with a single block comment",
+        target,
+        |edit| {
+            // We pick a single indentation level for the whole block comment based on the
+            // comment where the assist was invoked. This will be prepended to the
+            // contents of each line comment when they're put into the block comment.
+            let indentation = IndentLevel::from_token(&comment.syntax());
+
+            let block_comment_body =
+                comments.into_iter().map(|c| line_comment_text(indentation, c)).join("\n");
+
+            let block_prefix =
+                comment_kind_prefix(CommentKind { shape: CommentShape::Block, ..comment.kind() });
+
+            let output =
+                format!("{}\n{}\n{}*/", block_prefix, block_comment_body, indentation.to_string());
+
+            edit.replace(target, output)
+        },
+    )
+}
+
+/// The line -> block assist can  be invoked from anywhere within a sequence of line comments.
+/// relevant_line_comments crawls backwards and forwards finding the complete sequence of comments that will
+/// be joined.
+fn relevant_line_comments(comment: &ast::Comment) -> Vec<Comment> {
+    // The prefix identifies the kind of comment we're dealing with
+    let prefix = comment.prefix();
+    let same_prefix = |c: &ast::Comment| c.prefix() == prefix;
+
+    // These tokens are allowed to exist between comments
+    let skippable = |not: &SyntaxElement| {
+        not.clone()
+            .into_token()
+            .and_then(Whitespace::cast)
+            .map(|w| !w.spans_multiple_lines())
+            .unwrap_or(false)
+    };
+
+    // Find all preceding comments (in reverse order) that have the same prefix
+    let prev_comments = comment
+        .syntax()
+        .siblings_with_tokens(Direction::Prev)
+        .filter(|s| !skippable(s))
+        .map(|not| not.into_token().and_then(Comment::cast).filter(same_prefix))
+        .take_while(|opt_com| opt_com.is_some())
+        .filter_map(identity)
+        .skip(1); // skip the first element so we don't duplicate it in next_comments
+
+    let next_comments = comment
+        .syntax()
+        .siblings_with_tokens(Direction::Next)
+        .filter(|s| !skippable(s))
+        .map(|not| not.into_token().and_then(Comment::cast).filter(same_prefix))
+        .take_while(|opt_com| opt_com.is_some())
+        .filter_map(identity);
+
+    let mut comments: Vec<_> = prev_comments.collect();
+    comments.reverse();
+    comments.extend(next_comments);
+    comments
+}
+
+// Line comments usually begin with a single space character following the prefix as seen here:
+//^
+// But comments can also include indented text:
+//    > Hello there
+//
+// We handle this by stripping *AT MOST* one space character from the start of the line
+// This has its own problems because it can cause alignment issues:
+//
+//              /*
+// a      ----> a
+//b       ----> b
+//              */
+//
+// But since such comments aren't idiomatic we're okay with this.
+fn line_comment_text(indentation: IndentLevel, comm: ast::Comment) -> String {
+    let contents_without_prefix = comm.text().strip_prefix(comm.prefix()).unwrap();
+    let contents = contents_without_prefix.strip_prefix(' ').unwrap_or(contents_without_prefix);
+
+    // Don't add the indentation if the line is empty
+    if contents.is_empty() {
+        contents.to_owned()
+    } else {
+        indentation.to_string() + &contents
+    }
+}
+
+fn comment_kind_prefix(ck: ast::CommentKind) -> &'static str {
+    match (ck.shape, ck.doc) {
+        (Line, Some(Inner)) => "//!",
+        (Line, Some(Outer)) => "///",
+        (Line, None) => "//",
+        (Block, Some(Inner)) => "/*!",
+        (Block, Some(Outer)) => "/**",
+        (Block, None) => "/*",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn single_line_to_block() {
+        check_assist(
+            convert_comment_block,
+            r#"
+// line$0 comment
+fn main() {
+    foo();
+}
+"#,
+            r#"
+/*
+line comment
+*/
+fn main() {
+    foo();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn single_line_to_block_indented() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    // line$0 comment
+    foo();
+}
+"#,
+            r#"
+fn main() {
+    /*
+    line comment
+    */
+    foo();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn multiline_to_block() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    // above
+    // line$0 comment
+    //
+    // below
+    foo();
+}
+"#,
+            r#"
+fn main() {
+    /*
+    above
+    line comment
+
+    below
+    */
+    foo();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn end_of_line_to_block() {
+        check_assist_not_applicable(
+            convert_comment_block,
+            r#"
+fn main() {
+    foo(); // end-of-line$0 comment
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn single_line_different_kinds() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    /// different prefix
+    // line$0 comment
+    // below
+    foo();
+}
+"#,
+            r#"
+fn main() {
+    /// different prefix
+    /*
+    line comment
+    below
+    */
+    foo();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn single_line_separate_chunks() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    // different chunk
+
+    // line$0 comment
+    // below
+    foo();
+}
+"#,
+            r#"
+fn main() {
+    // different chunk
+
+    /*
+    line comment
+    below
+    */
+    foo();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn doc_block_comment_to_lines() {
+        check_assist(
+            convert_comment_block,
+            r#"
+/**
+ hi$0 there
+*/
+"#,
+            r#"
+/// hi there
+"#,
+        );
+    }
+
+    #[test]
+    fn block_comment_to_lines() {
+        check_assist(
+            convert_comment_block,
+            r#"
+/*
+ hi$0 there
+*/
+"#,
+            r#"
+// hi there
+"#,
+        );
+    }
+
+    #[test]
+    fn inner_doc_block_to_lines() {
+        check_assist(
+            convert_comment_block,
+            r#"
+/*!
+ hi$0 there
+*/
+"#,
+            r#"
+//! hi there
+"#,
+        );
+    }
+
+    #[test]
+    fn block_to_lines_indent() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    /*!
+    hi$0 there
+
+    ```
+      code_sample
+    ```
+    */
+}
+"#,
+            r#"
+fn main() {
+    //! hi there
+    //!
+    //! ```
+    //!   code_sample
+    //! ```
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn end_of_line_block_to_line() {
+        check_assist_not_applicable(
+            convert_comment_block,
+            r#"
+fn main() {
+    foo(); /* end-of-line$0 comment */
+}
+"#,
+        );
+    }
+}
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 53542d433..9c8148462 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -115,6 +115,7 @@ mod handlers {
     mod auto_import;
     mod change_visibility;
     mod convert_integer_literal;
+    mod convert_comment_block;
     mod early_return;
     mod expand_glob_import;
     mod extract_function;
@@ -178,6 +179,7 @@ mod handlers {
             auto_import::auto_import,
             change_visibility::change_visibility,
             convert_integer_literal::convert_integer_literal,
+            convert_comment_block::convert_comment_block,
             early_return::convert_to_guarded_return,
             expand_glob_import::expand_glob_import,
             extract_struct_from_enum_variant::extract_struct_from_enum_variant,
diff --git a/crates/mbe/Cargo.toml b/crates/mbe/Cargo.toml
index bbee2e32c..8b5cca22c 100644
--- a/crates/mbe/Cargo.toml
+++ b/crates/mbe/Cargo.toml
@@ -19,8 +19,5 @@ parser = { path = "../parser", version = "0.0.0" }
 tt = { path = "../tt", version = "0.0.0" }
 test_utils = { path = "../test_utils", version = "0.0.0" }
 
-# FIXME: Paper over a bug in cargo-worspaces which block publishing
-# https://github.com/pksunkara/cargo-workspaces/issues/39
-# [dev-dependencies]
-profile = { path = "../profile", version = "0.0.0" }
-
+[dev-dependencies]
+profile = { path = "../profile" }
diff --git a/crates/proc_macro_srv/src/rustc_server.rs b/crates/proc_macro_srv/src/rustc_server.rs
index a8504f762..952b4a97f 100644
--- a/crates/proc_macro_srv/src/rustc_server.rs
+++ b/crates/proc_macro_srv/src/rustc_server.rs
@@ -14,7 +14,6 @@ use std::collections::HashMap;
 use std::hash::Hash;
 use std::iter::FromIterator;
 use std::ops::Bound;
-use std::str::FromStr;
 use std::{ascii, vec::IntoIter};
 
 type Group = tt::Subtree;
@@ -278,6 +277,42 @@ impl server::FreeFunctions for Rustc {
     }
 }
 
+fn subtree_replace_token_ids_with_unspecified(subtree: tt::Subtree) -> tt::Subtree {
+    tt::Subtree {
+        delimiter: subtree.delimiter.map(|d| tt::Delimiter { id: tt::TokenId::unspecified(), ..d }),
+        token_trees: subtree
+            .token_trees
+            .into_iter()
+            .map(|t| token_tree_replace_token_ids_with_unspecified(t))
+            .collect(),
+    }
+}
+
+fn token_tree_replace_token_ids_with_unspecified(tt: tt::TokenTree) -> tt::TokenTree {
+    match tt {
+        tt::TokenTree::Leaf(leaf) => {
+            tt::TokenTree::Leaf(leaf_replace_token_ids_with_unspecified(leaf))
+        }
+        tt::TokenTree::Subtree(subtree) => {
+            tt::TokenTree::Subtree(subtree_replace_token_ids_with_unspecified(subtree))
+        }
+    }
+}
+
+fn leaf_replace_token_ids_with_unspecified(leaf: tt::Leaf) -> tt::Leaf {
+    match leaf {
+        tt::Leaf::Literal(lit) => {
+            tt::Leaf::Literal(tt::Literal { id: tt::TokenId::unspecified(), ..lit })
+        }
+        tt::Leaf::Punct(punct) => {
+            tt::Leaf::Punct(tt::Punct { id: tt::TokenId::unspecified(), ..punct })
+        }
+        tt::Leaf::Ident(ident) => {
+            tt::Leaf::Ident(tt::Ident { id: tt::TokenId::unspecified(), ..ident })
+        }
+    }
+}
+
 impl server::TokenStream for Rustc {
     fn new(&mut self) -> Self::TokenStream {
         Self::TokenStream::new()
@@ -287,7 +322,8 @@ impl server::TokenStream for Rustc {
         stream.is_empty()
     }
     fn from_str(&mut self, src: &str) -> Self::TokenStream {
-        Self::TokenStream::from_str(src).expect("cannot parse string")
+        let (subtree, _) = mbe::parse_to_token_tree(src).expect("cannot parse string");
+        TokenStream::with_subtree(subtree_replace_token_ids_with_unspecified(subtree))
     }
     fn to_string(&mut self, stream: &Self::TokenStream) -> String {
         stream.to_string()
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index b881cc229..8789f0852 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -24,7 +24,7 @@ jod-thread = "0.1.0"
 log = "0.4.8"
 lsp-types = { version = "0.88.0", features = ["proposed"] }
 parking_lot = "0.11.0"
-pico-args = "0.4.0"
+xflags = "0.1.2"
 oorandom = "11.1.2"
 rustc-hash = "1.1.0"
 serde = { version = "1.0.106", features = ["derive"] }
diff --git a/crates/rust-analyzer/src/bin/args.rs b/crates/rust-analyzer/src/bin/args.rs
deleted file mode 100644
index 164d94a30..000000000
--- a/crates/rust-analyzer/src/bin/args.rs
+++ /dev/null
@@ -1,274 +0,0 @@
-//! Command like parsing for rust-analyzer.
-//!
-//! If run started args, we run the LSP server loop. With a subcommand, we do a
-//! one-time batch processing.
-
-use std::{env, path::PathBuf};
-
-use anyhow::{bail, format_err, Result};
-use ide_ssr::{SsrPattern, SsrRule};
-use pico_args::Arguments;
-use rust_analyzer::cli::{AnalysisStatsCmd, BenchCmd, BenchWhat, Position, Verbosity};
-use vfs::AbsPathBuf;
-
-pub(crate) struct Args {
-    pub(crate) verbosity: Verbosity,
-    pub(crate) log_file: Option<PathBuf>,
-    pub(crate) no_buffering: bool,
-    pub(crate) command: Command,
-    #[allow(unused)]
-    pub(crate) wait_dbg: bool,
-}
-
-pub(crate) enum Command {
-    Parse { no_dump: bool },
-    Symbols,
-    Highlight { rainbow: bool },
-    AnalysisStats(AnalysisStatsCmd),
-    Bench(BenchCmd),
-    Diagnostics { path: PathBuf, load_output_dirs: bool, with_proc_macro: bool },
-    Ssr { rules: Vec<SsrRule> },
-    StructuredSearch { debug_snippet: Option<String>, patterns: Vec<SsrPattern> },
-    ProcMacro,
-    RunServer,
-    PrintConfigSchema,
-    Version,
-    Help,
-}
-
-const HELP: &str = "\
-rust-analyzer
-
-USAGE:
-    rust-analyzer [FLAGS] [COMMAND] [COMMAND_OPTIONS]
-
-FLAGS:
-    --version         Print version
-    -h, --help        Print this help
-
-    -v,  --verbose
-    -vv, --spammy
-    -q,  --quiet      Set verbosity
-
-    --print-config-schema
-                      Dump a LSP config JSON schema
-    --log-file <PATH> Log to the specified file instead of stderr
-    --no-log-buffering
-                      Flush log records to the file immediately
-
-    --wait-dbg        Wait until a debugger is attached to.
-                      The flag is valid for debug builds only
-
-ENVIRONMENTAL VARIABLES:
-    RA_LOG            Set log filter in env_logger format
-    RA_PROFILE        Enable hierarchical profiler
-    RA_WAIT_DBG       If set acts like a --wait-dbg flag
-
-COMMANDS:
-
-not specified         Launch LSP server
-
-parse < main.rs       Parse tree
-    --no-dump         Suppress printing
-
-symbols < main.rs     Parse input an print the list of symbols
-
-highlight < main.rs   Highlight input as html
-    --rainbow         Enable rainbow highlighting of identifiers
-
-analysis-stats <PATH> Batch typecheck project and print summary statistics
-    <PATH>            Directory with Cargo.toml
-    --randomize       Randomize order in which crates, modules, and items are processed
-    --parallel        Run type inference in parallel
-    --memory-usage    Collect memory usage statistics
-    -o, --only <PATH> Only analyze items matching this path
-    --with-deps       Also analyze all dependencies
-    --load-output-dirs
-                      Load OUT_DIR values by running `cargo check` before analysis
-    --with-proc-macro Use proc-macro-srv for proc-macro expanding
-
-analysis-bench <PATH> Benchmark specific analysis operation
-    <PATH>            Directory with Cargo.toml
-    --highlight <PATH>
-                      Compute syntax highlighting for this file
-    --complete <PATH:LINE:COLUMN>
-                      Compute completions at this location
-    --goto-def <PATH:LINE:COLUMN>
-                      Compute goto definition at this location
-    --memory-usage    Collect memory usage statistics
-    --load-output-dirs
-                      Load OUT_DIR values by running `cargo check` before analysis
-    --with-proc-macro Use proc-macro-srv for proc-macro expanding
-
-diagnostics <PATH>
-    <PATH>            Directory with Cargo.toml
-    --load-output-dirs
-                      Load OUT_DIR values by running `cargo check` before analysis
-    --with-proc-macro Use proc-macro-srv for proc-macro expanding
-
-ssr [RULE...]
-    <RULE>            A structured search replace rule (`$a.foo($b) ==> bar($a, $b)`)
-
-search [PATTERN..]
-    <PATTERN>         A structured search replace pattern (`$a.foo($b)`)
-    --debug <snippet> Prints debug information for any nodes with source exactly
-                      equal to <snippet>
-";
-
-impl Args {
-    pub(crate) fn parse() -> Result<Args> {
-        let mut matches = Arguments::from_env();
-
-        if matches.contains("--version") {
-            finish_args(matches)?;
-            return Ok(Args {
-                verbosity: Verbosity::Normal,
-                log_file: None,
-                command: Command::Version,
-                no_buffering: false,
-                wait_dbg: false,
-            });
-        }
-
-        let verbosity = match (
-            matches.contains(["-vv", "--spammy"]),
-            matches.contains(["-v", "--verbose"]),
-            matches.contains(["-q", "--quiet"]),
-        ) {
-            (true, _, true) => bail!("Invalid flags: -q conflicts with -vv"),
-            (true, _, false) => Verbosity::Spammy,
-            (false, false, false) => Verbosity::Normal,
-            (false, false, true) => Verbosity::Quiet,
-            (false, true, false) => Verbosity::Verbose,
-            (false, true, true) => bail!("Invalid flags: -q conflicts with -v"),
-        };
-        let log_file = matches.opt_value_from_str("--log-file")?;
-        let no_buffering = matches.contains("--no-log-buffering");
-        let wait_dbg = matches.contains("--wait-dbg");
-
-        if matches.contains(["-h", "--help"]) {
-            eprintln!("{}", HELP);
-            return Ok(Args {
-                verbosity,
-                log_file: None,
-                command: Command::Help,
-                no_buffering,
-                wait_dbg,
-            });
-        }
-
-        if matches.contains("--print-config-schema") {
-            return Ok(Args {
-                verbosity,
-                log_file,
-                command: Command::PrintConfigSchema,
-                no_buffering,
-                wait_dbg,
-            });
-        }
-
-        let subcommand = match matches.subcommand()? {
-            Some(it) => it,
-            None => {
-                finish_args(matches)?;
-                return Ok(Args {
-                    verbosity,
-                    log_file,
-                    command: Command::RunServer,
-                    no_buffering,
-                    wait_dbg,
-                });
-            }
-        };
-        let command = match subcommand.as_str() {
-            "parse" => Command::Parse { no_dump: matches.contains("--no-dump") },
-            "symbols" => Command::Symbols,
-            "highlight" => Command::Highlight { rainbow: matches.contains("--rainbow") },
-            "analysis-stats" => Command::AnalysisStats(AnalysisStatsCmd {
-                randomize: matches.contains("--randomize"),
-                parallel: matches.contains("--parallel"),
-                memory_usage: matches.contains("--memory-usage"),
-                only: matches.opt_value_from_str(["-o", "--only"])?,
-                with_deps: matches.contains("--with-deps"),
-                load_output_dirs: matches.contains("--load-output-dirs"),
-                with_proc_macro: matches.contains("--with-proc-macro"),
-                path: matches
-                    .opt_free_from_str()?
-                    .ok_or_else(|| format_err!("expected positional argument"))?,
-            }),
-            "analysis-bench" => Command::Bench(BenchCmd {
-                what: {
-                    let highlight_path: Option<String> =
-                        matches.opt_value_from_str("--highlight")?;
-                    let complete_path: Option<Position> =
-                        matches.opt_value_from_str("--complete")?;
-                    let goto_def_path: Option<Position> =
-                        matches.opt_value_from_str("--goto-def")?;
-                    match (highlight_path, complete_path, goto_def_path) {
-                            (Some(path), None, None) => {
-                                let path = env::current_dir().unwrap().join(path);
-                                BenchWhat::Highlight { path: AbsPathBuf::assert(path) }
-                            }
-                            (None, Some(position), None) => BenchWhat::Complete(position),
-                            (None, None, Some(position)) => BenchWhat::GotoDef(position),
-                            _ => panic!(
-                                "exactly one of  `--highlight`, `--complete` or `--goto-def` must be set"
-                            ),
-                        }
-                },
-                memory_usage: matches.contains("--memory-usage"),
-                load_output_dirs: matches.contains("--load-output-dirs"),
-                with_proc_macro: matches.contains("--with-proc-macro"),
-                path: matches
-                    .opt_free_from_str()?
-                    .ok_or_else(|| format_err!("expected positional argument"))?,
-            }),
-            "diagnostics" => Command::Diagnostics {
-                load_output_dirs: matches.contains("--load-output-dirs"),
-                with_proc_macro: matches.contains("--with-proc-macro"),
-                path: matches
-                    .opt_free_from_str()?
-                    .ok_or_else(|| format_err!("expected positional argument"))?,
-            },
-            "proc-macro" => Command::ProcMacro,
-            "ssr" => Command::Ssr {
-                rules: {
-                    let mut acc = Vec::new();
-                    while let Some(rule) = matches.opt_free_from_str()? {
-                        acc.push(rule);
-                    }
-                    acc
-                },
-            },
-            "search" => Command::StructuredSearch {
-                debug_snippet: matches.opt_value_from_str("--debug")?,
-                patterns: {
-                    let mut acc = Vec::new();
-                    while let Some(rule) = matches.opt_free_from_str()? {
-                        acc.push(rule);
-                    }
-                    acc
-                },
-            },
-            _ => {
-                eprintln!("{}", HELP);
-                return Ok(Args {
-                    verbosity,
-                    log_file: None,
-                    command: Command::Help,
-                    no_buffering,
-                    wait_dbg,
-                });
-            }
-        };
-        finish_args(matches)?;
-        Ok(Args { verbosity, log_file, command, no_buffering, wait_dbg })
-    }
-}
-
-fn finish_args(args: Arguments) -> Result<()> {
-    if !args.finish().is_empty() {
-        bail!("Unused arguments.");
-    }
-    Ok(())
-}
diff --git a/crates/rust-analyzer/src/bin/flags.rs b/crates/rust-analyzer/src/bin/flags.rs
new file mode 100644
index 000000000..244912d26
--- /dev/null
+++ b/crates/rust-analyzer/src/bin/flags.rs
@@ -0,0 +1,251 @@
+//! Grammar for the command-line arguments.
+#![allow(unreachable_pub)]
+use std::{env, path::PathBuf};
+
+use ide_ssr::{SsrPattern, SsrRule};
+use rust_analyzer::cli::{BenchWhat, Position, Verbosity};
+use vfs::AbsPathBuf;
+
+xflags::args_parser! {
+    /// LSP server for the Rust programming language.
+    cmd rust-analyzer {
+        /// Verbosity level, can be repeated multiple times.
+        repeated -v, --verbose
+        /// Verbosity level.
+        optional -q, --quiet
+
+        /// Log to the specified file instead of stderr.
+        optional --log-file path: PathBuf
+        /// Flush log records to the file immediately.
+        optional --no-log-buffering
+
+        /// Wait until a debugger is attached to (requires debug build).
+        optional --wait-dbg
+
+        default cmd lsp-server {
+            /// Print version.
+            optional --version
+            /// Print help.
+            optional -h, --help
+
+            /// Dump a LSP config JSON schema.
+            optional --print-config-schema
+        }
+
+        /// Parse stdin.
+        cmd parse {
+            /// Suppress printing.
+            optional --no-dump
+        }
+
+        /// Parse stdin and print the list of symbols.
+        cmd symbols {}
+
+        /// Highlight stdin as html.
+        cmd highlight {
+            /// Enable rainbow highlighting of identifiers.
+            optional --rainbow
+        }
+
+        /// Batch typecheck project and print summary statistics
+        cmd analysis-stats
+            /// Directory with Cargo.toml.
+            required path: PathBuf
+        {
+            /// Randomize order in which crates, modules, and items are processed.
+            optional --randomize
+            /// Run type inference in parallel.
+            optional --parallel
+            /// Collect memory usage statistics.
+            optional --memory-usage
+
+            /// Only analyze items matching this path.
+            optional -o, --only path: String
+            /// Also analyze all dependencies.
+            optional --with-deps
+
+            /// Load OUT_DIR values by running `cargo check` before analysis.
+            optional --load-output-dirs
+            /// Use proc-macro-srv for proc-macro expanding.
+            optional --with-proc-macro
+        }
+
+        /// Benchmark specific analysis operation
+        cmd analysis-bench
+            /// Directory with Cargo.toml.
+            required path: PathBuf
+        {
+            /// Collect memory usage statistics.
+            optional --memory-usage
+
+            /// Compute syntax highlighting for this file
+            optional --highlight path: PathBuf
+            /// Compute completions at file:line:column location.
+            optional --complete location: Position
+            /// Compute goto definition at file:line:column location.
+            optional --goto-def location: Position
+
+            /// Load OUT_DIR values by running `cargo check` before analysis.
+            optional --load-output-dirs
+            /// Use proc-macro-srv for proc-macro expanding.
+            optional --with-proc-macro
+        }
+
+        cmd diagnostics
+            /// Directory with Cargo.toml.
+            required path: PathBuf
+        {
+            /// Load OUT_DIR values by running `cargo check` before analysis.
+            optional --load-output-dirs
+            /// Use proc-macro-srv for proc-macro expanding.
+            optional --with-proc-macro
+        }
+
+        cmd ssr
+            /// A structured search replace rule (`$a.foo($b) ==> bar($a, $b)`)
+            repeated rule: SsrRule
+        {}
+
+        cmd search
+            /// A structured search replace pattern (`$a.foo($b)`)
+            repeated pattern: SsrPattern
+        {
+            /// Prints debug information for any nodes with source exactly equal to snippet.
+            optional --debug snippet: String
+        }
+
+        cmd proc-macro {}
+    }
+}
+
+// generated start
+// The following code is generated by `xflags` macro.
+// Run `env XFLAGS_DUMP= cargo build` to regenerate.
+#[derive(Debug)]
+pub struct RustAnalyzer {
+    pub verbose: u32,
+    pub quiet: bool,
+    pub log_file: Option<PathBuf>,
+    pub no_log_buffering: bool,
+    pub wait_dbg: bool,
+    pub subcommand: RustAnalyzerCmd,
+}
+
+#[derive(Debug)]
+pub enum RustAnalyzerCmd {
+    LspServer(LspServer),
+    Parse(Parse),
+    Symbols(Symbols),
+    Highlight(Highlight),
+    AnalysisStats(AnalysisStats),
+    AnalysisBench(AnalysisBench),
+    Diagnostics(Diagnostics),
+    Ssr(Ssr),
+    Search(Search),
+    ProcMacro(ProcMacro),
+}
+
+#[derive(Debug)]
+pub struct LspServer {
+    pub version: bool,
+    pub help: bool,
+    pub print_config_schema: bool,
+}
+
+#[derive(Debug)]
+pub struct Parse {
+    pub no_dump: bool,
+}
+
+#[derive(Debug)]
+pub struct Symbols {}
+
+#[derive(Debug)]
+pub struct Highlight {
+    pub rainbow: bool,
+}
+
+#[derive(Debug)]
+pub struct AnalysisStats {
+    pub path: PathBuf,
+
+    pub randomize: bool,
+    pub parallel: bool,
+    pub memory_usage: bool,
+    pub only: Option<String>,
+    pub with_deps: bool,
+    pub load_output_dirs: bool,
+    pub with_proc_macro: bool,
+}
+
+#[derive(Debug)]
+pub struct AnalysisBench {
+    pub path: PathBuf,
+
+    pub memory_usage: bool,
+    pub highlight: Option<PathBuf>,
+    pub complete: Option<Position>,
+    pub goto_def: Option<Position>,
+    pub load_output_dirs: bool,
+    pub with_proc_macro: bool,
+}
+
+#[derive(Debug)]
+pub struct Diagnostics {
+    pub path: PathBuf,
+
+    pub load_output_dirs: bool,
+    pub with_proc_macro: bool,
+}
+
+#[derive(Debug)]
+pub struct Ssr {
+    pub rule: Vec<SsrRule>,
+}
+
+#[derive(Debug)]
+pub struct Search {
+    pub pattern: Vec<SsrPattern>,
+
+    pub debug: Option<String>,
+}
+
+#[derive(Debug)]
+pub struct ProcMacro {}
+
+impl RustAnalyzer {
+    pub const HELP: &'static str = Self::_HELP;
+
+    pub fn from_env() -> xflags::Result<Self> {
+        let mut p = xflags::rt::Parser::new_from_env();
+        Self::_parse(&mut p)
+    }
+}
+// generated end
+
+impl RustAnalyzer {
+    pub(crate) fn verbosity(&self) -> Verbosity {
+        if self.quiet {
+            return Verbosity::Quiet;
+        }
+        match self.verbose {
+            0 => Verbosity::Normal,
+            1 => Verbosity::Verbose,
+            _ => Verbosity::Spammy,
+        }
+    }
+}
+
+impl AnalysisBench {
+    pub(crate) fn what(&self) -> BenchWhat {
+        match (&self.highlight, &self.complete, &self.goto_def) {
+            (Some(path), None, None) => {
+                let path = env::current_dir().unwrap().join(path);
+                BenchWhat::Highlight { path: AbsPathBuf::assert(path) }
+            }
+            (None, Some(position), None) => BenchWhat::Complete(position.clone()),
+            (None, None, Some(position)) => BenchWhat::GotoDef(position.clone()),
+            _ => panic!("exactly one of  `--highlight`, `--complete` or `--goto-def` must be set"),
+        }
+    }
+}
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 89482b952..288847980 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -1,14 +1,20 @@
 //! Driver for rust-analyzer.
 //!
 //! Based on cli flags, either spawns an LSP server, or runs a batch analysis
-mod args;
+mod flags;
 mod logger;
 
-use std::{convert::TryFrom, env, fs, path::PathBuf, process};
+use std::{convert::TryFrom, env, fs, path::Path, process};
 
 use lsp_server::Connection;
 use project_model::ProjectManifest;
-use rust_analyzer::{cli, config::Config, from_json, lsp_ext::supports_utf8, Result};
+use rust_analyzer::{
+    cli::{self, AnalysisStatsCmd, BenchCmd},
+    config::Config,
+    from_json,
+    lsp_ext::supports_utf8,
+    Result,
+};
 use vfs::AbsPathBuf;
 
 #[cfg(all(feature = "mimalloc"))]
@@ -28,10 +34,10 @@ fn main() {
 }
 
 fn try_main() -> Result<()> {
-    let args = args::Args::parse()?;
+    let flags = flags::RustAnalyzer::from_env()?;
 
     #[cfg(debug_assertions)]
-    if args.wait_dbg || env::var("RA_WAIT_DBG").is_ok() {
+    if flags.wait_dbg || env::var("RA_WAIT_DBG").is_ok() {
         #[allow(unused_mut)]
         let mut d = 4;
         while d == 4 {
@@ -39,35 +45,62 @@ fn try_main() -> Result<()> {
         }
     }
 
-    setup_logging(args.log_file, args.no_buffering)?;
-    match args.command {
-        args::Command::RunServer => run_server()?,
-        args::Command::PrintConfigSchema => {
-            println!("{:#}", Config::json_schema());
+    setup_logging(flags.log_file.as_deref(), flags.no_log_buffering)?;
+    let verbosity = flags.verbosity();
+
+    match flags.subcommand {
+        flags::RustAnalyzerCmd::LspServer(cmd) => {
+            if cmd.print_config_schema {
+                println!("{:#}", Config::json_schema());
+                return Ok(());
+            }
+            if cmd.version {
+                println!("rust-analyzer {}", env!("REV"));
+                return Ok(());
+            }
+            if cmd.help {
+                println!("{}", flags::RustAnalyzer::HELP);
+                return Ok(());
+            }
+            run_server()?
         }
-        args::Command::ProcMacro => proc_macro_srv::cli::run()?,
-
-        args::Command::Parse { no_dump } => cli::parse(no_dump)?,
-        args::Command::Symbols => cli::symbols()?,
-        args::Command::Highlight { rainbow } => cli::highlight(rainbow)?,
-        args::Command::AnalysisStats(cmd) => cmd.run(args.verbosity)?,
-        args::Command::Bench(cmd) => cmd.run(args.verbosity)?,
-        args::Command::Diagnostics { path, load_output_dirs, with_proc_macro } => {
-            cli::diagnostics(path.as_ref(), load_output_dirs, with_proc_macro)?
+        flags::RustAnalyzerCmd::ProcMacro(_) => proc_macro_srv::cli::run()?,
+        flags::RustAnalyzerCmd::Parse(cmd) => cli::parse(cmd.no_dump)?,
+        flags::RustAnalyzerCmd::Symbols(_) => cli::symbols()?,
+        flags::RustAnalyzerCmd::Highlight(cmd) => cli::highlight(cmd.rainbow)?,
+        flags::RustAnalyzerCmd::AnalysisStats(cmd) => AnalysisStatsCmd {
+            randomize: cmd.randomize,
+            parallel: cmd.parallel,
+            memory_usage: cmd.memory_usage,
+            only: cmd.only,
+            with_deps: cmd.with_deps,
+            path: cmd.path,
+            load_output_dirs: cmd.load_output_dirs,
+            with_proc_macro: cmd.with_proc_macro,
         }
-        args::Command::Ssr { rules } => {
-            cli::apply_ssr_rules(rules)?;
+        .run(verbosity)?,
+        flags::RustAnalyzerCmd::AnalysisBench(cmd) => {
+            let what = cmd.what();
+            BenchCmd {
+                memory_usage: cmd.memory_usage,
+                path: cmd.path,
+                load_output_dirs: cmd.load_output_dirs,
+                with_proc_macro: cmd.with_proc_macro,
+                what,
+            }
+            .run(verbosity)?
         }
-        args::Command::StructuredSearch { patterns, debug_snippet } => {
-            cli::search_for_patterns(patterns, debug_snippet)?;
+
+        flags::RustAnalyzerCmd::Diagnostics(cmd) => {
+            cli::diagnostics(&cmd.path, cmd.load_output_dirs, cmd.with_proc_macro)?
         }
-        args::Command::Version => println!("rust-analyzer {}", env!("REV")),
-        args::Command::Help => {}
+        flags::RustAnalyzerCmd::Ssr(cmd) => cli::apply_ssr_rules(cmd.rule)?,
+        flags::RustAnalyzerCmd::Search(cmd) => cli::search_for_patterns(cmd.pattern, cmd.debug)?,
     }
     Ok(())
 }
 
-fn setup_logging(log_file: Option<PathBuf>, no_buffering: bool) -> Result<()> {
+fn setup_logging(log_file: Option<&Path>, no_buffering: bool) -> Result<()> {
     env::set_var("RUST_BACKTRACE", "short");
 
     let log_file = match log_file {
diff --git a/crates/rust-analyzer/src/cli/analysis_bench.rs b/crates/rust-analyzer/src/cli/analysis_bench.rs
index 8991f3bdb..3bd7e678d 100644
--- a/crates/rust-analyzer/src/cli/analysis_bench.rs
+++ b/crates/rust-analyzer/src/cli/analysis_bench.rs
@@ -35,6 +35,7 @@ pub enum BenchWhat {
     GotoDef(Position),
 }
 
+#[derive(Debug, Clone)]
 pub struct Position {
     pub path: AbsPathBuf,
     pub line: u32,
@@ -68,7 +69,7 @@ impl BenchCmd {
             load_out_dirs_from_check: self.load_output_dirs,
             with_proc_macro: self.with_proc_macro,
         };
-        let (mut host, vfs) =
+        let (mut host, vfs, _proc_macro) =
             load_workspace_at(&self.path, &cargo_config, &load_cargo_config, &|_| {})?;
         eprintln!("{:?}\n", start.elapsed());
 
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 9072d8944..ad0759bda 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -64,7 +64,7 @@ impl AnalysisStatsCmd {
             load_out_dirs_from_check: self.load_output_dirs,
             with_proc_macro: self.with_proc_macro,
         };
-        let (host, vfs) =
+        let (host, vfs, _proc_macro) =
             load_workspace_at(&self.path, &cargo_config, &load_cargo_config, &|_| {})?;
         let db = host.raw_database();
         eprintln!("{:<20} {}", "Database loaded:", db_load_sw.elapsed());
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
index 876f6c44f..8b985716b 100644
--- a/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -35,7 +35,8 @@ pub fn diagnostics(
 ) -> Result<()> {
     let cargo_config = Default::default();
     let load_cargo_config = LoadCargoConfig { load_out_dirs_from_check, with_proc_macro };
-    let (host, _vfs) = load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
+    let (host, _vfs, _proc_macro) =
+        load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
     let db = host.raw_database();
     let analysis = host.analysis();
 
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index 23442afac..310c36904 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -23,7 +23,7 @@ pub fn load_workspace_at(
     cargo_config: &CargoConfig,
     load_config: &LoadCargoConfig,
     progress: &dyn Fn(String),
-) -> Result<(AnalysisHost, vfs::Vfs)> {
+) -> Result<(AnalysisHost, vfs::Vfs, Option<ProcMacroClient>)> {
     let root = AbsPathBuf::assert(std::env::current_dir()?.join(root));
     let root = ProjectManifest::discover_single(&root)?;
     let workspace = ProjectWorkspace::load(root, cargo_config, progress)?;
@@ -35,7 +35,7 @@ pub fn load_workspace(
     ws: ProjectWorkspace,
     config: &LoadCargoConfig,
     progress: &dyn Fn(String),
-) -> Result<(AnalysisHost, vfs::Vfs)> {
+) -> Result<(AnalysisHost, vfs::Vfs, Option<ProcMacroClient>)> {
     let (sender, receiver) = unbounded();
     let mut vfs = vfs::Vfs::default();
     let mut loader = {
@@ -80,7 +80,7 @@ pub fn load_workspace(
     log::debug!("crate graph: {:?}", crate_graph);
     let host =
         load_crate_graph(crate_graph, project_folders.source_root_config, &mut vfs, &receiver);
-    Ok((host, vfs))
+    Ok((host, vfs, proc_macro_client))
 }
 
 fn load_crate_graph(
@@ -138,7 +138,8 @@ mod tests {
         let cargo_config = Default::default();
         let load_cargo_config =
             LoadCargoConfig { load_out_dirs_from_check: false, with_proc_macro: false };
-        let (host, _vfs) = load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
+        let (host, _vfs, _proc_macro) =
+            load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
 
         let n_crates = Crate::all(host.raw_database()).len();
         // RA has quite a few crates, but the exact count doesn't matter
diff --git a/crates/rust-analyzer/src/cli/ssr.rs b/crates/rust-analyzer/src/cli/ssr.rs
index 71a8f8fb9..79f426fff 100644
--- a/crates/rust-analyzer/src/cli/ssr.rs
+++ b/crates/rust-analyzer/src/cli/ssr.rs
@@ -11,7 +11,7 @@ pub fn apply_ssr_rules(rules: Vec<SsrRule>) -> Result<()> {
     let cargo_config = Default::default();
     let load_cargo_config =
         LoadCargoConfig { load_out_dirs_from_check: true, with_proc_macro: true };
-    let (host, vfs) =
+    let (host, vfs, _proc_macro) =
         load_workspace_at(&std::env::current_dir()?, &cargo_config, &load_cargo_config, &|_| {})?;
     let db = host.raw_database();
     let mut match_finder = MatchFinder::at_first_file(db)?;
@@ -38,7 +38,7 @@ pub fn search_for_patterns(patterns: Vec<SsrPattern>, debug_snippet: Option<Stri
     let cargo_config = Default::default();
     let load_cargo_config =
         LoadCargoConfig { load_out_dirs_from_check: true, with_proc_macro: true };
-    let (host, _vfs) =
+    let (host, _vfs, _proc_macro) =
         load_workspace_at(&std::env::current_dir()?, &cargo_config, &load_cargo_config, &|_| {})?;
     let db = host.raw_database();
     let mut match_finder = MatchFinder::at_first_file(db)?;
diff --git a/crates/syntax/src/ast/edit.rs b/crates/syntax/src/ast/edit.rs
index 824ebf41c..0b3b76d4a 100644
--- a/crates/syntax/src/ast/edit.rs
+++ b/crates/syntax/src/ast/edit.rs
@@ -595,11 +595,14 @@ impl ops::Add<u8> for IndentLevel {
 
 impl IndentLevel {
     pub fn from_node(node: &SyntaxNode) -> IndentLevel {
-        let first_token = match node.first_token() {
-            Some(it) => it,
+        match node.first_token() {
+            Some(it) => Self::from_token(&it),
             None => return IndentLevel(0),
-        };
-        for ws in prev_tokens(first_token).filter_map(ast::Whitespace::cast) {
+        }
+    }
+
+    pub fn from_token(token: &SyntaxToken) -> IndentLevel {
+        for ws in prev_tokens(token.clone()).filter_map(ast::Whitespace::cast) {
             let text = ws.syntax().text();
             if let Some(pos) = text.rfind('\n') {
                 let level = text[pos + 1..].chars().count() / 4;
diff --git a/crates/syntax/src/ast/token_ext.rs b/crates/syntax/src/ast/token_ext.rs
index 044e3e5e8..977eb8181 100644
--- a/crates/syntax/src/ast/token_ext.rs
+++ b/crates/syntax/src/ast/token_ext.rs
@@ -85,8 +85,9 @@ pub enum CommentPlacement {
 }
 
 impl CommentKind {
-    const BY_PREFIX: [(&'static str, CommentKind); 8] = [
+    const BY_PREFIX: [(&'static str, CommentKind); 9] = [
         ("/**/", CommentKind { shape: CommentShape::Block, doc: None }),
+        ("/***", CommentKind { shape: CommentShape::Block, doc: None }),
         ("////", CommentKind { shape: CommentShape::Line, doc: None }),
         ("///", CommentKind { shape: CommentShape::Line, doc: Some(CommentPlacement::Outer) }),
         ("//!", CommentKind { shape: CommentShape::Line, doc: Some(CommentPlacement::Inner) }),
diff --git a/docs/dev/README.md b/docs/dev/README.md
index d6fae5295..b91013f13 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -58,8 +58,6 @@ Use `env RUN_SLOW_TESTS=1 cargo test` to run the full suite.
 
 We use bors-ng to enforce the [not rocket science](https://graydon2.dreamwidth.org/1597.html) rule.
 
-You can run `cargo xtask install-pre-commit-hook` to install git-hook to run rustfmt on commit.
-
 # Launching rust-analyzer
 
 Debugging the language server can be tricky.
diff --git a/editors/code/README.md b/editors/code/README.md
index e7d7a06f0..241489226 100644
--- a/editors/code/README.md
+++ b/editors/code/README.md
@@ -2,18 +2,36 @@
 
 Provides support for rust-analyzer: novel LSP server for the Rust programming language.
 
+**Note** the extension may cause conflicts with the official Rust extension. It is recommended to disable the Rust extension when using the rust-analyzer extension.
 
-Features:
+**Note** the project is in alpha status: it is already useful in practice, but can't be considered stable.
 
-* [code completion], [imports insertion]
-* [go to definition], [implementation], [type definition]
-* [find all references], [workspace symbol search], [rename]
-* [types and documentation on hover]
-* [inlay hints]
-* [semantic syntax highlighting]
-* a lot of [assist(code actions)]
-* apply suggestions from errors
-* ... and many more, checkout the [manual] to see them all
+## Sponsor
+
+Work on rust-analyzer is sponsored by
+
+[<img src="https://user-images.githubusercontent.com/1711539/58105231-cf306900-7bee-11e9-83d8-9f1102e59d29.png" alt="Ferrous Systems" width="300">](https://ferrous-systems.com/)
+
+- [Mozilla](https://www.mozilla.org/en-US/)
+- [Embark Studios](https://embark-studios.com/)
+- [freiheit.com](https://www.freiheit.com)
+
+If you want to sponsor:
+
+- [OpenCollective](https://opencollective.com/rust-analyzer/)
+- [Github Sponsors](https://github.com/sponsors/rust-analyzer)
+
+## Features
+
+- [code completion], [imports insertion]
+- [go to definition], [implementation], [type definition]
+- [find all references], [workspace symbol search], [rename]
+- [types and documentation on hover]
+- [inlay hints]
+- [semantic syntax highlighting]
+- a lot of [assist(code actions)]
+- apply suggestions from errors
+- ... and many more, checkout the [manual] to see them all
 
 [code completion]: https://rust-analyzer.github.io/manual.html#magic-completions
 [imports insertion]: https://rust-analyzer.github.io/manual.html#auto-import
@@ -30,4 +48,26 @@ Features:
 
 [manual]: https://rust-analyzer.github.io/manual.html
 
-See https://rust-analyzer.github.io/ for more information.
+## Quick start
+
+1. Install [rustup]
+2. Install the [rust-analyzer extension]
+
+[rustup]: https://rustup.rs
+[rust-analyzer extension]: https://marketplace.visualstudio.com/items?itemName=matklad.rust-analyzer
+
+## Configuration
+
+This extension provides configurations through VSCode's configuration settings. All the configurations are under `rust-analyzer.*`.
+
+See <https://rust-analyzer.github.io/manual.html#vs-code-2> for more information on VSCode specific configurations.
+
+## Communication
+
+For usage and troubleshooting requests, please use "IDEs and Editors" category of the Rust forum:
+
+<https://users.rust-lang.org/c/ide/14>
+
+## Documentation
+
+See <https://rust-analyzer.github.io/> for more information.
diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml
index b379797f9..b17dde598 100644
--- a/xtask/Cargo.toml
+++ b/xtask/Cargo.toml
@@ -6,17 +6,14 @@ authors = ["rust-analyzer developers"]
 publish = false
 license = "MIT OR Apache-2.0"
 
-[lib]
-doctest = false
-
 [dependencies]
 anyhow = "1.0.26"
 flate2 = "1.0"
-pico-args = "0.4.0"
 proc-macro2 = "1.0.8"
 quote = "1.0.2"
 ungrammar = "=1.11"
 walkdir = "2.3.1"
 write-json = "0.1.0"
 xshell = "0.1"
+xflags = "0.1.2"
 # Avoid adding more dependencies to this crate
diff --git a/xtask/src/codegen.rs b/xtask/src/codegen.rs
index adea053b6..2f56c5ad0 100644
--- a/xtask/src/codegen.rs
+++ b/xtask/src/codegen.rs
@@ -18,9 +18,9 @@ use std::{
 };
 use xshell::{cmd, pushenv, read_file, write_file};
 
-use crate::{ensure_rustfmt, project_root, Result};
+use crate::{ensure_rustfmt, flags, project_root, Result};
 
-pub use self::{
+pub(crate) use self::{
     gen_assists_docs::{generate_assists_docs, generate_assists_tests},
     gen_diagnostic_docs::generate_diagnostic_docs,
     gen_feature_docs::generate_feature_docs,
@@ -30,17 +30,13 @@ pub use self::{
 };
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub enum Mode {
+pub(crate) enum Mode {
     Overwrite,
     Verify,
 }
 
-pub struct CodegenCmd {
-    pub features: bool,
-}
-
-impl CodegenCmd {
-    pub fn run(self) -> Result<()> {
+impl flags::Codegen {
+    pub(crate) fn run(self) -> Result<()> {
         if self.features {
             generate_lint_completions(Mode::Overwrite)?;
         }
diff --git a/xtask/src/codegen/gen_assists_docs.rs b/xtask/src/codegen/gen_assists_docs.rs
index 1ae1343a5..c469b388d 100644
--- a/xtask/src/codegen/gen_assists_docs.rs
+++ b/xtask/src/codegen/gen_assists_docs.rs
@@ -7,12 +7,12 @@ use crate::{
     project_root, rust_files_in, Result,
 };
 
-pub fn generate_assists_tests(mode: Mode) -> Result<()> {
+pub(crate) fn generate_assists_tests(mode: Mode) -> Result<()> {
     let assists = Assist::collect()?;
     generate_tests(&assists, mode)
 }
 
-pub fn generate_assists_docs(mode: Mode) -> Result<()> {
+pub(crate) fn generate_assists_docs(mode: Mode) -> Result<()> {
     let assists = Assist::collect()?;
     let contents = assists.into_iter().map(|it| it.to_string()).collect::<Vec<_>>().join("\n\n");
     let contents = format!("//{}\n{}\n", PREAMBLE, contents.trim());
diff --git a/xtask/src/codegen/gen_diagnostic_docs.rs b/xtask/src/codegen/gen_diagnostic_docs.rs
index 7c14d4a07..a2561817b 100644
--- a/xtask/src/codegen/gen_diagnostic_docs.rs
+++ b/xtask/src/codegen/gen_diagnostic_docs.rs
@@ -7,7 +7,7 @@ use crate::{
     project_root, rust_files, Result,
 };
 
-pub fn generate_diagnostic_docs(mode: Mode) -> Result<()> {
+pub(crate) fn generate_diagnostic_docs(mode: Mode) -> Result<()> {
     let diagnostics = Diagnostic::collect()?;
     let contents =
         diagnostics.into_iter().map(|it| it.to_string()).collect::<Vec<_>>().join("\n\n");
diff --git a/xtask/src/codegen/gen_feature_docs.rs b/xtask/src/codegen/gen_feature_docs.rs
index 61081063b..cad7ff477 100644
--- a/xtask/src/codegen/gen_feature_docs.rs
+++ b/xtask/src/codegen/gen_feature_docs.rs
@@ -7,7 +7,7 @@ use crate::{
     project_root, rust_files, Result,
 };
 
-pub fn generate_feature_docs(mode: Mode) -> Result<()> {
+pub(crate) fn generate_feature_docs(mode: Mode) -> Result<()> {
     let features = Feature::collect()?;
     let contents = features.into_iter().map(|it| it.to_string()).collect::<Vec<_>>().join("\n\n");
     let contents = format!("//{}\n{}\n", PREAMBLE, contents.trim());
diff --git a/xtask/src/codegen/gen_lint_completions.rs b/xtask/src/codegen/gen_lint_completions.rs
index 8c51d35c7..b1c057037 100644
--- a/xtask/src/codegen/gen_lint_completions.rs
+++ b/xtask/src/codegen/gen_lint_completions.rs
@@ -10,7 +10,7 @@ use crate::{
     run_rustfmt,
 };
 
-pub fn generate_lint_completions(mode: Mode) -> Result<()> {
+pub(crate) fn generate_lint_completions(mode: Mode) -> Result<()> {
     if !Path::new("./target/rust").exists() {
         cmd!("git clone --depth=1 https://github.com/rust-lang/rust ./target/rust").run()?;
     }
diff --git a/xtask/src/codegen/gen_parser_tests.rs b/xtask/src/codegen/gen_parser_tests.rs
index 6e4abd10c..cb8939063 100644
--- a/xtask/src/codegen/gen_parser_tests.rs
+++ b/xtask/src/codegen/gen_parser_tests.rs
@@ -12,7 +12,7 @@ use crate::{
     project_root, Result,
 };
 
-pub fn generate_parser_tests(mode: Mode) -> Result<()> {
+pub(crate) fn generate_parser_tests(mode: Mode) -> Result<()> {
     let tests = tests_from_dir(&project_root().join(Path::new("crates/parser/src/grammar")))?;
     fn install_tests(tests: &HashMap<String, Test>, into: &str, mode: Mode) -> Result<()> {
         let tests_dir = project_root().join(into);
diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs
index eb524d85a..191bc0e9d 100644
--- a/xtask/src/codegen/gen_syntax.rs
+++ b/xtask/src/codegen/gen_syntax.rs
@@ -18,7 +18,7 @@ use crate::{
     project_root, Result,
 };
 
-pub fn generate_syntax(mode: Mode) -> Result<()> {
+pub(crate) fn generate_syntax(mode: Mode) -> Result<()> {
     let grammar = rust_grammar();
     let ast = lower(&grammar);
 
diff --git a/xtask/src/dist.rs b/xtask/src/dist.rs
index 56bf9f99d..f2503f807 100644
--- a/xtask/src/dist.rs
+++ b/xtask/src/dist.rs
@@ -11,13 +11,13 @@ use xshell::{cmd, cp, mkdir_p, pushd, read_file, rm_rf, write_file};
 
 use crate::{date_iso, project_root};
 
-pub struct DistCmd {
-    pub nightly: bool,
-    pub client_version: Option<String>,
+pub(crate) struct DistCmd {
+    pub(crate) nightly: bool,
+    pub(crate) client_version: Option<String>,
 }
 
 impl DistCmd {
-    pub fn run(self) -> Result<()> {
+    pub(crate) fn run(self) -> Result<()> {
         let dist = project_root().join("dist");
         rm_rf(&dist)?;
         mkdir_p(&dist)?;
diff --git a/xtask/src/flags.rs b/xtask/src/flags.rs
new file mode 100644
index 000000000..5710fbdb5
--- /dev/null
+++ b/xtask/src/flags.rs
@@ -0,0 +1,139 @@
+#![allow(unreachable_pub)]
+
+xflags::args_parser! {
+    /// Run custom build command.
+    cmd xtask {
+        default cmd help {
+            /// Print help information.
+            optional -h, --help
+        }
+
+        /// Install rust-analyzer server or editor plugin.
+        cmd install {
+            /// Install only VS Code plugin.
+            optional --client
+            /// One of 'code', 'code-exploration', 'code-insiders', 'codium', or 'code-oss'.
+            optional --code-bin name: String
+
+            /// Install only the language server.
+            optional --server
+            /// Use mimalloc allocator for server
+            optional --mimalloc
+            /// Use jemalloc allocator for server
+            optional --jemalloc
+        }
+
+        cmd codegen {
+            optional --features
+        }
+
+        cmd lint {}
+        cmd fuzz-tests {}
+        cmd pre-cache {}
+
+        cmd release {
+            optional --dry-run
+        }
+        cmd promote {
+            optional --dry-run
+        }
+        cmd dist {
+            optional --nightly
+            optional --client version: String
+        }
+        cmd metrics {
+            optional --dry-run
+        }
+        /// Builds a benchmark version of rust-analyzer and puts it into `./target`.
+        cmd bb
+            required suffix: String
+        {}
+    }
+}
+
+// generated start
+// The following code is generated by `xflags` macro.
+// Run `env XFLAGS_DUMP= cargo build` to regenerate.
+#[derive(Debug)]
+pub struct Xtask {
+    pub subcommand: XtaskCmd,
+}
+
+#[derive(Debug)]
+pub enum XtaskCmd {
+    Help(Help),
+    Install(Install),
+    Codegen(Codegen),
+    Lint(Lint),
+    FuzzTests(FuzzTests),
+    PreCache(PreCache),
+    Release(Release),
+    Promote(Promote),
+    Dist(Dist),
+    Metrics(Metrics),
+    Bb(Bb),
+}
+
+#[derive(Debug)]
+pub struct Help {
+    pub help: bool,
+}
+
+#[derive(Debug)]
+pub struct Install {
+    pub client: bool,
+    pub code_bin: Option<String>,
+    pub server: bool,
+    pub mimalloc: bool,
+    pub jemalloc: bool,
+}
+
+#[derive(Debug)]
+pub struct Codegen {
+    pub features: bool,
+}
+
+#[derive(Debug)]
+pub struct Lint {}
+
+#[derive(Debug)]
+pub struct FuzzTests {}
+
+#[derive(Debug)]
+pub struct PreCache {}
+
+#[derive(Debug)]
+pub struct Release {
+    pub dry_run: bool,
+}
+
+#[derive(Debug)]
+pub struct Promote {
+    pub dry_run: bool,
+}
+
+#[derive(Debug)]
+pub struct Dist {
+    pub nightly: bool,
+    pub client: Option<String>,
+}
+
+#[derive(Debug)]
+pub struct Metrics {
+    pub dry_run: bool,
+}
+
+#[derive(Debug)]
+pub struct Bb {
+    pub suffix: String,
+}
+
+impl Xtask {
+    pub const HELP: &'static str = Self::_HELP;
+
+    pub fn from_env() -> xflags::Result<Self> {
+        let mut p = xflags::rt::Parser::new_from_env();
+        Self::_parse(&mut p)
+    }
+}
+// generated end
diff --git a/xtask/src/install.rs b/xtask/src/install.rs
index 4c5c2673c..ea2194248 100644
--- a/xtask/src/install.rs
+++ b/xtask/src/install.rs
@@ -8,13 +8,13 @@ use xshell::{cmd, pushd};
 // Latest stable, feel free to send a PR if this lags behind.
 const REQUIRED_RUST_VERSION: u32 = 50;
 
-pub struct InstallCmd {
-    pub client: Option<ClientOpt>,
-    pub server: Option<ServerOpt>,
+pub(crate) struct InstallCmd {
+    pub(crate) client: Option<ClientOpt>,
+    pub(crate) server: Option<ServerOpt>,
 }
 
 #[derive(Clone, Copy)]
-pub enum ClientOpt {
+pub(crate) enum ClientOpt {
     VsCode,
     VsCodeExploration,
     VsCodeInsiders,
@@ -24,7 +24,7 @@ pub enum ClientOpt {
 }
 
 impl ClientOpt {
-    pub const fn as_cmds(&self) -> &'static [&'static str] {
+    pub(crate) const fn as_cmds(&self) -> &'static [&'static str] {
         match self {
             ClientOpt::VsCode => &["code"],
             ClientOpt::VsCodeExploration => &["code-exploration"],
@@ -60,18 +60,18 @@ impl std::str::FromStr for ClientOpt {
     }
 }
 
-pub struct ServerOpt {
-    pub malloc: Malloc,
+pub(crate) struct ServerOpt {
+    pub(crate) malloc: Malloc,
 }
 
-pub enum Malloc {
+pub(crate) enum Malloc {
     System,
     Mimalloc,
     Jemalloc,
 }
 
 impl InstallCmd {
-    pub fn run(self) -> Result<()> {
+    pub(crate) fn run(self) -> Result<()> {
         if cfg!(target_os = "macos") {
             fix_path_for_mac().context("Fix path for mac")?
         }
diff --git a/xtask/src/lib.rs b/xtask/src/lib.rs
deleted file mode 100644
index b19985fb2..000000000
--- a/xtask/src/lib.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-//! Support library for `cargo xtask` command.
-//!
-//! See https://github.com/matklad/cargo-xtask/
-
-pub mod codegen;
-mod ast_src;
-
-pub mod install;
-pub mod release;
-pub mod dist;
-pub mod pre_commit;
-pub mod metrics;
-pub mod pre_cache;
-
-use std::{
-    env,
-    path::{Path, PathBuf},
-};
-
-use walkdir::{DirEntry, WalkDir};
-use xshell::{cmd, pushd, pushenv};
-
-use crate::codegen::Mode;
-
-pub use anyhow::{bail, Context as _, Result};
-
-pub fn project_root() -> PathBuf {
-    Path::new(
-        &env::var("CARGO_MANIFEST_DIR").unwrap_or_else(|_| env!("CARGO_MANIFEST_DIR").to_owned()),
-    )
-    .ancestors()
-    .nth(1)
-    .unwrap()
-    .to_path_buf()
-}
-
-pub fn rust_files() -> impl Iterator<Item = PathBuf> {
-    rust_files_in(&project_root().join("crates"))
-}
-
-pub fn cargo_files() -> impl Iterator<Item = PathBuf> {
-    files_in(&project_root(), "toml")
-        .filter(|path| path.file_name().map(|it| it == "Cargo.toml").unwrap_or(false))
-}
-
-pub fn rust_files_in(path: &Path) -> impl Iterator<Item = PathBuf> {
-    files_in(path, "rs")
-}
-
-pub fn run_rustfmt(mode: Mode) -> Result<()> {
-    let _dir = pushd(project_root())?;
-    let _e = pushenv("RUSTUP_TOOLCHAIN", "stable");
-    ensure_rustfmt()?;
-    let check = match mode {
-        Mode::Overwrite => &[][..],
-        Mode::Verify => &["--", "--check"],
-    };
-    cmd!("cargo fmt {check...}").run()?;
-    Ok(())
-}
-
-fn ensure_rustfmt() -> Result<()> {
-    let out = cmd!("rustfmt --version").read()?;
-    if !out.contains("stable") {
-        bail!(
-            "Failed to run rustfmt from toolchain 'stable'. \
-             Please run `rustup component add rustfmt --toolchain stable` to install it.",
-        )
-    }
-    Ok(())
-}
-
-pub fn run_clippy() -> Result<()> {
-    if cmd!("cargo clippy --version").read().is_err() {
-        bail!(
-            "Failed run cargo clippy. \
-            Please run `rustup component add clippy` to install it.",
-        )
-    }
-
-    let allowed_lints = "
-        -A clippy::collapsible_if
-        -A clippy::needless_pass_by_value
-        -A clippy::nonminimal_bool
-        -A clippy::redundant_pattern_matching
-    "
-    .split_ascii_whitespace();
-    cmd!("cargo clippy --all-features --all-targets -- {allowed_lints...}").run()?;
-    Ok(())
-}
-
-pub fn run_fuzzer() -> Result<()> {
-    let _d = pushd("./crates/syntax")?;
-    let _e = pushenv("RUSTUP_TOOLCHAIN", "nightly");
-    if cmd!("cargo fuzz --help").read().is_err() {
-        cmd!("cargo install cargo-fuzz").run()?;
-    };
-
-    // Expecting nightly rustc
-    let out = cmd!("rustc --version").read()?;
-    if !out.contains("nightly") {
-        bail!("fuzz tests require nightly rustc")
-    }
-
-    cmd!("cargo fuzz run parser").run()?;
-    Ok(())
-}
-
-fn date_iso() -> Result<String> {
-    let res = cmd!("date --iso --utc").read()?;
-    Ok(res)
-}
-
-fn is_release_tag(tag: &str) -> bool {
-    tag.len() == "2020-02-24".len() && tag.starts_with(|c: char| c.is_ascii_digit())
-}
-
-fn files_in(path: &Path, ext: &'static str) -> impl Iterator<Item = PathBuf> {
-    let iter = WalkDir::new(path);
-    return iter
-        .into_iter()
-        .filter_entry(|e| !is_hidden(e))
-        .map(|e| e.unwrap())
-        .filter(|e| !e.file_type().is_dir())
-        .map(|e| e.into_path())
-        .filter(move |path| path.extension().map(|it| it == ext).unwrap_or(false));
-
-    fn is_hidden(entry: &DirEntry) -> bool {
-        entry.file_name().to_str().map(|s| s.starts_with('.')).unwrap_or(false)
-    }
-}
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index cbb9b315e..e419db7a7 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -7,59 +7,44 @@
 //!
 //! This binary is integrated into the `cargo` command line by using an alias in
 //! `.cargo/config`.
+mod flags;
 
-use std::env;
+mod codegen;
+mod ast_src;
+#[cfg(test)]
+mod tidy;
 
-use anyhow::bail;
-use codegen::CodegenCmd;
-use pico_args::Arguments;
-use xshell::{cmd, cp, pushd};
-use xtask::{
-    codegen::{self, Mode},
+mod install;
+mod release;
+mod dist;
+mod metrics;
+mod pre_cache;
+
+use anyhow::{bail, Result};
+use std::{
+    env,
+    path::{Path, PathBuf},
+};
+use walkdir::{DirEntry, WalkDir};
+use xshell::{cmd, cp, pushd, pushenv};
+
+use crate::{
+    codegen::Mode,
     dist::DistCmd,
     install::{InstallCmd, Malloc, ServerOpt},
-    metrics::MetricsCmd,
-    pre_cache::PreCacheCmd,
-    pre_commit, project_root,
-    release::{PromoteCmd, ReleaseCmd},
-    run_clippy, run_fuzzer, run_rustfmt, Result,
 };
 
 fn main() -> Result<()> {
-    if env::args().next().map(|it| it.contains("pre-commit")) == Some(true) {
-        return pre_commit::run_hook();
-    }
-
     let _d = pushd(project_root())?;
 
-    let mut args = Arguments::from_env();
-    let subcommand = args.subcommand()?.unwrap_or_default();
-
-    match subcommand.as_str() {
-        "install" => {
-            if args.contains(["-h", "--help"]) {
-                eprintln!(
-                    "\
-cargo xtask install
-Install rust-analyzer server or editor plugin.
-
-USAGE:
-    cargo xtask install [FLAGS]
-
-FLAGS:
-        --client[=CLIENT] Install only VS Code plugin.
-                          CLIENT is one of 'code', 'code-exploration', 'code-insiders', 'codium', or 'code-oss'
-        --server          Install only the language server
-        --mimalloc        Use mimalloc allocator for server
-        --jemalloc        Use jemalloc allocator for server
-    -h, --help            Prints help information
-        "
-                );
-                return Ok(());
-            }
-            let server = args.contains("--server");
-            let client_code = args.contains("--client");
-            if server && client_code {
+    let flags = flags::Xtask::from_env()?;
+    match flags.subcommand {
+        flags::XtaskCmd::Help(_) => {
+            println!("{}", flags::Xtask::HELP);
+            return Ok(());
+        }
+        flags::XtaskCmd::Install(flags) => {
+            if flags.server && flags.client {
                 eprintln!(
                     "error: The argument `--server` cannot be used with `--client`\n\n\
                      For more information try --help"
@@ -67,108 +52,146 @@ FLAGS:
                 return Ok(());
             }
 
-            let malloc = if args.contains("--mimalloc") {
+            let malloc = if flags.mimalloc {
                 Malloc::Mimalloc
-            } else if args.contains("--jemalloc") {
+            } else if flags.jemalloc {
                 Malloc::Jemalloc
             } else {
                 Malloc::System
             };
 
-            let client_opt = args.opt_value_from_str("--client")?;
-
-            finish_args(args)?;
+            let client_bin = flags.code_bin.map(|it| it.parse()).transpose()?;
 
             InstallCmd {
-                client: if server { None } else { Some(client_opt.unwrap_or_default()) },
-                server: if client_code { None } else { Some(ServerOpt { malloc }) },
+                client: if flags.server { None } else { client_bin },
+                server: if flags.client { None } else { Some(ServerOpt { malloc }) },
             }
             .run()
         }
-        "codegen" => {
-            let features = args.contains("--features");
-            finish_args(args)?;
-            CodegenCmd { features }.run()
-        }
-        "format" => {
-            finish_args(args)?;
-            run_rustfmt(Mode::Overwrite)
-        }
-        "install-pre-commit-hook" => {
-            finish_args(args)?;
-            pre_commit::install_hook()
+        flags::XtaskCmd::Codegen(cmd) => cmd.run(),
+        flags::XtaskCmd::Lint(_) => run_clippy(),
+        flags::XtaskCmd::FuzzTests(_) => run_fuzzer(),
+        flags::XtaskCmd::PreCache(cmd) => cmd.run(),
+        flags::XtaskCmd::Release(cmd) => cmd.run(),
+        flags::XtaskCmd::Promote(cmd) => cmd.run(),
+        flags::XtaskCmd::Dist(flags) => {
+            DistCmd { nightly: flags.nightly, client_version: flags.client }.run()
         }
-        "lint" => {
-            finish_args(args)?;
-            run_clippy()
-        }
-        "fuzz-tests" => {
-            finish_args(args)?;
-            run_fuzzer()
-        }
-        "pre-cache" => {
-            finish_args(args)?;
-            PreCacheCmd.run()
-        }
-        "release" => {
-            let dry_run = args.contains("--dry-run");
-            finish_args(args)?;
-            ReleaseCmd { dry_run }.run()
-        }
-        "promote" => {
-            let dry_run = args.contains("--dry-run");
-            finish_args(args)?;
-            PromoteCmd { dry_run }.run()
-        }
-        "dist" => {
-            let nightly = args.contains("--nightly");
-            let client_version: Option<String> = args.opt_value_from_str("--client")?;
-            finish_args(args)?;
-            DistCmd { nightly, client_version }.run()
-        }
-        "metrics" => {
-            let dry_run = args.contains("--dry-run");
-            finish_args(args)?;
-            MetricsCmd { dry_run }.run()
-        }
-        "bb" => {
-            let suffix: String = args.free_from_str()?;
-            finish_args(args)?;
+        flags::XtaskCmd::Metrics(cmd) => cmd.run(),
+        flags::XtaskCmd::Bb(cmd) => {
             {
                 let _d = pushd("./crates/rust-analyzer")?;
                 cmd!("cargo build --release --features jemalloc").run()?;
             }
-            cp("./target/release/rust-analyzer", format!("./target/rust-analyzer-{}", suffix))?;
-            Ok(())
-        }
-        _ => {
-            eprintln!(
-                "\
-cargo xtask
-Run custom build command.
-
-USAGE:
-    cargo xtask <SUBCOMMAND>
-
-SUBCOMMANDS:
-    format
-    install-pre-commit-hook
-    fuzz-tests
-    codegen
-    install
-    lint
-    dist
-    promote
-    bb"
-            );
+            cp("./target/release/rust-analyzer", format!("./target/rust-analyzer-{}", cmd.suffix))?;
             Ok(())
         }
     }
 }
 
-fn finish_args(args: Arguments) -> Result<()> {
-    if !args.finish().is_empty() {
-        bail!("Unused arguments.");
+fn project_root() -> PathBuf {
+    Path::new(
+        &env::var("CARGO_MANIFEST_DIR").unwrap_or_else(|_| env!("CARGO_MANIFEST_DIR").to_owned()),
+    )
+    .ancestors()
+    .nth(1)
+    .unwrap()
+    .to_path_buf()
+}
+
+fn rust_files() -> impl Iterator<Item = PathBuf> {
+    rust_files_in(&project_root().join("crates"))
+}
+
+#[cfg(test)]
+fn cargo_files() -> impl Iterator<Item = PathBuf> {
+    files_in(&project_root(), "toml")
+        .filter(|path| path.file_name().map(|it| it == "Cargo.toml").unwrap_or(false))
+}
+
+fn rust_files_in(path: &Path) -> impl Iterator<Item = PathBuf> {
+    files_in(path, "rs")
+}
+
+fn run_rustfmt(mode: Mode) -> Result<()> {
+    let _dir = pushd(project_root())?;
+    let _e = pushenv("RUSTUP_TOOLCHAIN", "stable");
+    ensure_rustfmt()?;
+    let check = match mode {
+        Mode::Overwrite => &[][..],
+        Mode::Verify => &["--", "--check"],
+    };
+    cmd!("cargo fmt {check...}").run()?;
+    Ok(())
+}
+
+fn ensure_rustfmt() -> Result<()> {
+    let out = cmd!("rustfmt --version").read()?;
+    if !out.contains("stable") {
+        bail!(
+            "Failed to run rustfmt from toolchain 'stable'. \
+             Please run `rustup component add rustfmt --toolchain stable` to install it.",
+        )
+    }
+    Ok(())
+}
+
+fn run_clippy() -> Result<()> {
+    if cmd!("cargo clippy --version").read().is_err() {
+        bail!(
+            "Failed run cargo clippy. \
+            Please run `rustup component add clippy` to install it.",
+        )
+    }
+
+    let allowed_lints = "
+        -A clippy::collapsible_if
+        -A clippy::needless_pass_by_value
+        -A clippy::nonminimal_bool
+        -A clippy::redundant_pattern_matching
+    "
+    .split_ascii_whitespace();
+    cmd!("cargo clippy --all-features --all-targets -- {allowed_lints...}").run()?;
+    Ok(())
+}
+
+fn run_fuzzer() -> Result<()> {
+    let _d = pushd("./crates/syntax")?;
+    let _e = pushenv("RUSTUP_TOOLCHAIN", "nightly");
+    if cmd!("cargo fuzz --help").read().is_err() {
+        cmd!("cargo install cargo-fuzz").run()?;
+    };
+
+    // Expecting nightly rustc
+    let out = cmd!("rustc --version").read()?;
+    if !out.contains("nightly") {
+        bail!("fuzz tests require nightly rustc")
     }
+
+    cmd!("cargo fuzz run parser").run()?;
     Ok(())
 }
+
+fn date_iso() -> Result<String> {
+    let res = cmd!("date --iso --utc").read()?;
+    Ok(res)
+}
+
+fn is_release_tag(tag: &str) -> bool {
+    tag.len() == "2020-02-24".len() && tag.starts_with(|c: char| c.is_ascii_digit())
+}
+
+fn files_in(path: &Path, ext: &'static str) -> impl Iterator<Item = PathBuf> {
+    let iter = WalkDir::new(path);
+    return iter
+        .into_iter()
+        .filter_entry(|e| !is_hidden(e))
+        .map(|e| e.unwrap())
+        .filter(|e| !e.file_type().is_dir())
+        .map(|e| e.into_path())
+        .filter(move |path| path.extension().map(|it| it == ext).unwrap_or(false));
+
+    fn is_hidden(entry: &DirEntry) -> bool {
+        entry.file_name().to_str().map(|s| s.starts_with('.')).unwrap_or(false)
+    }
+}
diff --git a/xtask/src/metrics.rs b/xtask/src/metrics.rs
index 624ad3b7e..eb58b3274 100644
--- a/xtask/src/metrics.rs
+++ b/xtask/src/metrics.rs
@@ -9,14 +9,12 @@ use std::{
 use anyhow::{bail, format_err, Result};
 use xshell::{cmd, mkdir_p, pushd, pushenv, read_file, rm_rf};
 
-type Unit = String;
+use crate::flags;
 
-pub struct MetricsCmd {
-    pub dry_run: bool,
-}
+type Unit = String;
 
-impl MetricsCmd {
-    pub fn run(self) -> Result<()> {
+impl flags::Metrics {
+    pub(crate) fn run(self) -> Result<()> {
         let mut metrics = Metrics::new()?;
         if !self.dry_run {
             rm_rf("./target/release")?;
diff --git a/xtask/src/pre_cache.rs b/xtask/src/pre_cache.rs
index 569f88f68..b456224fd 100644
--- a/xtask/src/pre_cache.rs
+++ b/xtask/src/pre_cache.rs
@@ -6,12 +6,12 @@ use std::{
 use anyhow::Result;
 use xshell::rm_rf;
 
-pub struct PreCacheCmd;
+use crate::flags;
 
-impl PreCacheCmd {
+impl flags::PreCache {
     /// Cleans the `./target` dir after the build such that only
     /// dependencies are cached on CI.
-    pub fn run(self) -> Result<()> {
+    pub(crate) fn run(self) -> Result<()> {
         let slow_tests_cookie = Path::new("./target/.slow_tests_cookie");
         if !slow_tests_cookie.exists() {
             panic!("slow tests were skipped on CI!")
diff --git a/xtask/src/pre_commit.rs b/xtask/src/pre_commit.rs
deleted file mode 100644
index 8f2dbea19..000000000
--- a/xtask/src/pre_commit.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-//! pre-commit hook for code formatting.
-
-use std::{fs, path::PathBuf};
-
-use anyhow::{bail, Result};
-use xshell::cmd;
-
-use crate::{project_root, run_rustfmt, Mode};
-
-// FIXME: if there are changed `.ts` files, also reformat TypeScript (by
-// shelling out to `npm fmt`).
-pub fn run_hook() -> Result<()> {
-    run_rustfmt(Mode::Overwrite)?;
-
-    let diff = cmd!("git diff --diff-filter=MAR --name-only --cached").read()?;
-
-    let root = project_root();
-    for line in diff.lines() {
-        let file = root.join(line);
-        cmd!("git update-index --add {file}").run()?;
-    }
-
-    Ok(())
-}
-
-pub fn install_hook() -> Result<()> {
-    let hook_path: PathBuf =
-        format!("./.git/hooks/pre-commit{}", std::env::consts::EXE_SUFFIX).into();
-
-    if hook_path.exists() {
-        bail!("Git hook already created");
-    }
-
-    let me = std::env::current_exe()?;
-    fs::copy(me, hook_path)?;
-
-    Ok(())
-}
diff --git a/xtask/src/release.rs b/xtask/src/release.rs
index 63556476d..d8d86fd63 100644
--- a/xtask/src/release.rs
+++ b/xtask/src/release.rs
@@ -2,14 +2,10 @@ use std::fmt::Write;
 
 use xshell::{cmd, cp, pushd, read_dir, write_file};
 
-use crate::{codegen, date_iso, is_release_tag, project_root, Mode, Result};
+use crate::{codegen, date_iso, flags, is_release_tag, project_root, Mode, Result};
 
-pub struct ReleaseCmd {
-    pub dry_run: bool,
-}
-
-impl ReleaseCmd {
-    pub fn run(self) -> Result<()> {
+impl flags::Release {
+    pub(crate) fn run(self) -> Result<()> {
         if !self.dry_run {
             cmd!("git switch release").run()?;
             cmd!("git fetch upstream --tags --force").run()?;
@@ -86,12 +82,8 @@ https://github.com/sponsors/rust-analyzer[GitHub Sponsors].
     }
 }
 
-pub struct PromoteCmd {
-    pub dry_run: bool,
-}
-
-impl PromoteCmd {
-    pub fn run(self) -> Result<()> {
+impl flags::Promote {
+    pub(crate) fn run(self) -> Result<()> {
         let _dir = pushd("../rust-rust-analyzer")?;
         cmd!("git switch master").run()?;
         cmd!("git fetch upstream").run()?;
diff --git a/xtask/tests/tidy.rs b/xtask/src/tidy.rs
index a72498a38..349ca14d0 100644
--- a/xtask/tests/tidy.rs
+++ b/xtask/src/tidy.rs
@@ -4,7 +4,8 @@ use std::{
 };
 
 use xshell::{cmd, read_file};
-use xtask::{
+
+use crate::{
     cargo_files,
     codegen::{self, Mode},
     project_root, run_rustfmt, rust_files,
@@ -100,21 +101,44 @@ fn cargo_files_are_tidy() {
         let mut section = None;
         for (line_no, text) in read_file(&cargo).unwrap().lines().enumerate() {
             let text = text.trim();
-            if text.starts_with("[") {
+            if text.starts_with('[') {
+                if !text.ends_with(']') {
+                    panic!(
+                        "\nplease don't add comments or trailing whitespace in section lines.\n\
+                            {}:{}\n",
+                        cargo.display(),
+                        line_no + 1
+                    )
+                }
                 section = Some(text);
                 continue;
             }
-            if !section.map(|it| it.starts_with("[dependencies")).unwrap_or(false) {
+            let text: String = text.split_whitespace().collect();
+            if !text.contains("path=") {
                 continue;
             }
-            let text: String = text.split_whitespace().collect();
-            if text.contains("path=") && !text.contains("version") {
-                panic!(
-                    "\ncargo internal dependencies should have version.\n\
-                     {}:{}\n",
-                    cargo.display(),
-                    line_no + 1
-                )
+            match section {
+                Some(s) if s.contains("dev-dependencies") => {
+                    if text.contains("version") {
+                        panic!(
+                            "\ncargo internal dev-dependencies should not have a version.\n\
+                            {}:{}\n",
+                            cargo.display(),
+                            line_no + 1
+                        );
+                    }
+                }
+                Some(s) if s.contains("dependencies") => {
+                    if !text.contains("version") {
+                        panic!(
+                            "\ncargo internal dependencies should have a version.\n\
+                            {}:{}\n",
+                            cargo.display(),
+                            line_no + 1
+                        );
+                    }
+                }
+                _ => {}
             }
         }
     }