16 files changed, 175 insertions, 107 deletions

diff --git a/crates/paths/src/lib.rs b/crates/paths/src/lib.rs
index c7ce0c42f..190c50913 100644
--- a/crates/paths/src/lib.rs
+++ b/crates/paths/src/lib.rs
@@ -2,7 +2,7 @@
 //! relative paths.
 use std::{
     convert::{TryFrom, TryInto},
-    ops,
+    io, ops,
     path::{Component, Path, PathBuf},
 };
 
@@ -46,6 +46,9 @@ impl TryFrom<&str> for AbsPathBuf {
 }
 
 impl AbsPathBuf {
+    pub fn canonicalized(path: &Path) -> io::Result<AbsPathBuf> {
+        path.canonicalize().map(|it| AbsPathBuf::try_from(it).unwrap())
+    }
     pub fn as_path(&self) -> &AbsPath {
         AbsPath::new_unchecked(self.0.as_path())
     }
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index b3e5f491a..b8560fdc9 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -119,13 +119,6 @@ impl Default for ModuleOrigin {
 }
 
 impl ModuleOrigin {
-    pub(crate) fn not_sure_file(file: Option<FileId>, declaration: AstId<ast::Module>) -> Self {
-        match file {
-            None => ModuleOrigin::Inline { definition: declaration },
-            Some(definition) => ModuleOrigin::File { declaration, definition },
-        }
-    }
-
     fn declaration(&self) -> Option<AstId<ast::Module>> {
         match self {
             ModuleOrigin::File { declaration: module, .. }
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 976e5e585..77baa4c69 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -825,7 +825,10 @@ impl ModCollector<'_, '_> {
         let modules = &mut self.def_collector.def_map.modules;
         let res = modules.alloc(ModuleData::default());
         modules[res].parent = Some(self.module_id);
-        modules[res].origin = ModuleOrigin::not_sure_file(definition, declaration);
+        modules[res].origin = match definition {
+            None => ModuleOrigin::Inline { definition: declaration },
+            Some(definition) => ModuleOrigin::File { declaration, definition },
+        };
         for (name, mac) in modules[self.module_id].scope.collect_legacy_macros() {
             modules[res].scope.define_legacy_macro(name, mac)
         }
diff --git a/crates/ra_hir_ty/src/_match.rs b/crates/ra_hir_ty/src/_match.rs
index 02a7a61f1..5495ce284 100644
--- a/crates/ra_hir_ty/src/_match.rs
+++ b/crates/ra_hir_ty/src/_match.rs
@@ -312,20 +312,16 @@ impl PatStack {
         Self(v)
     }
 
-    fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-
-    fn head(&self) -> PatIdOrWild {
-        self.0[0]
-    }
-
     fn get_head(&self) -> Option<PatIdOrWild> {
         self.0.first().copied()
     }
 
+    fn tail(&self) -> &[PatIdOrWild] {
+        self.0.get(1..).unwrap_or(&[])
+    }
+
     fn to_tail(&self) -> PatStack {
-        Self::from_slice(&self.0[1..])
+        Self::from_slice(self.tail())
     }
 
     fn replace_head_with<I, T>(&self, pats: I) -> PatStack
@@ -347,7 +343,7 @@ impl PatStack {
     ///
     /// See the module docs and the associated documentation in rustc for details.
     fn specialize_wildcard(&self, cx: &MatchCheckCtx) -> Option<PatStack> {
-        if matches!(self.head().as_pat(cx), Pat::Wild) {
+        if matches!(self.get_head()?.as_pat(cx), Pat::Wild) {
             Some(self.to_tail())
         } else {
             None
@@ -362,11 +358,12 @@ impl PatStack {
         cx: &MatchCheckCtx,
         constructor: &Constructor,
     ) -> MatchCheckResult<Option<PatStack>> {
-        if self.is_empty() {
-            return Ok(None);
-        }
+        let head = match self.get_head() {
+            Some(head) => head,
+            None => return Ok(None),
+        };
 
-        let head_pat = self.head().as_pat(cx);
+        let head_pat = head.as_pat(cx);
         let result = match (head_pat, constructor) {
             (Pat::Tuple { args: ref pat_ids, ellipsis }, Constructor::Tuple { arity: _ }) => {
                 if ellipsis.is_some() {
@@ -394,7 +391,7 @@ impl PatStack {
             (Pat::Wild, constructor) => Some(self.expand_wildcard(cx, constructor)?),
             (Pat::Path(_), Constructor::Enum(constructor)) => {
                 // unit enum variants become `Pat::Path`
-                let pat_id = self.head().as_id().expect("we know this isn't a wild");
+                let pat_id = head.as_id().expect("we know this isn't a wild");
                 if !enum_variant_matches(cx, pat_id, *constructor) {
                     None
                 } else {
@@ -405,7 +402,7 @@ impl PatStack {
                 Pat::TupleStruct { args: ref pat_ids, ellipsis, .. },
                 Constructor::Enum(enum_constructor),
             ) => {
-                let pat_id = self.head().as_id().expect("we know this isn't a wild");
+                let pat_id = head.as_id().expect("we know this isn't a wild");
                 if !enum_variant_matches(cx, pat_id, *enum_constructor) {
                     None
                 } else {
@@ -445,7 +442,7 @@ impl PatStack {
                 }
             }
             (Pat::Record { args: ref arg_patterns, .. }, Constructor::Enum(e)) => {
-                let pat_id = self.head().as_id().expect("we know this isn't a wild");
+                let pat_id = head.as_id().expect("we know this isn't a wild");
                 if !enum_variant_matches(cx, pat_id, *e) {
                     None
                 } else {
@@ -491,7 +488,7 @@ impl PatStack {
     ) -> MatchCheckResult<PatStack> {
         assert_eq!(
             Pat::Wild,
-            self.head().as_pat(cx),
+            self.get_head().expect("expand_wildcard called on empty PatStack").as_pat(cx),
             "expand_wildcard must only be called on PatStack with wild at head",
         );
 
@@ -509,7 +506,6 @@ impl PatStack {
     }
 }
 
-#[derive(Debug)]
 /// A collection of PatStack.
 ///
 /// This type is modeled from the struct of the same name in `rustc`.
@@ -623,13 +619,16 @@ pub(crate) fn is_useful(
         _ => (),
     }
 
-    if v.is_empty() {
-        let result = if matrix.is_empty() { Usefulness::Useful } else { Usefulness::NotUseful };
+    let head = match v.get_head() {
+        Some(head) => head,
+        None => {
+            let result = if matrix.is_empty() { Usefulness::Useful } else { Usefulness::NotUseful };
 
-        return Ok(result);
-    }
+            return Ok(result);
+        }
+    };
 
-    if let Pat::Or(pat_ids) = v.head().as_pat(cx) {
+    if let Pat::Or(pat_ids) = head.as_pat(cx) {
         let mut found_unimplemented = false;
         let any_useful = pat_ids.iter().any(|&pat_id| {
             let v = PatStack::from_pattern(pat_id);
@@ -653,7 +652,7 @@ pub(crate) fn is_useful(
         };
     }
 
-    if let Some(constructor) = pat_constructor(cx, v.head())? {
+    if let Some(constructor) = pat_constructor(cx, head)? {
         let matrix = matrix.specialize_constructor(&cx, &constructor)?;
         let v = v
             .specialize_constructor(&cx, &constructor)?
@@ -854,10 +853,10 @@ mod tests {
     }
 
     pub(super) fn check_no_diagnostic(ra_fixture: &str) {
-        let diagnostic_count =
-            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().1;
+        let (s, diagnostic_count) =
+            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>();
 
-        assert_eq!(0, diagnostic_count, "expected no diagnostic, found one");
+        assert_eq!(0, diagnostic_count, "expected no diagnostic, found one: {}", s);
     }
 
     #[test]
@@ -2014,6 +2013,28 @@ mod tests {
         ",
         );
     }
+
+    #[test]
+    fn or_pattern_panic_2() {
+        // FIXME: This is a false positive, but the code used to cause a panic in the match checker,
+        // so this acts as a regression test for that.
+        check_diagnostic(
+            r"
+            pub enum Category {
+                Infinity,
+                Zero,
+            }
+
+            fn panic(a: Category, b: Category) {
+                match (a, b) {
+                    (Category::Infinity, Category::Infinity) | (Category::Zero, Category::Zero) => {}
+
+                    (Category::Infinity | Category::Zero, _) => {}
+                }
+            }
+        ",
+        );
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index c7bb1e69f..0b52b01ab 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -135,8 +135,8 @@ impl NavigationTarget {
         db: &RootDatabase,
         node: InFile<&dyn ast::NameOwner>,
     ) -> NavigationTarget {
-        //FIXME: use `_` instead of empty string
-        let name = node.value.name().map(|it| it.text().clone()).unwrap_or_default();
+        let name =
+            node.value.name().map(|it| it.text().clone()).unwrap_or_else(|| SmolStr::new("_"));
         let focus_range =
             node.value.name().map(|it| original_range(db, node.with_value(it.syntax())).range);
         let frange = original_range(db, node.map(|it| it.syntax()));
@@ -150,6 +150,25 @@ impl NavigationTarget {
         )
     }
 
+    /// Allows `NavigationTarget` to be created from a `DocCommentsOwner` and a `NameOwner`
+    pub(crate) fn from_doc_commented(
+        db: &RootDatabase,
+        named: InFile<&dyn ast::NameOwner>,
+        node: InFile<&dyn ast::DocCommentsOwner>,
+    ) -> NavigationTarget {
+        let name =
+            named.value.name().map(|it| it.text().clone()).unwrap_or_else(|| SmolStr::new("_"));
+        let frange = original_range(db, node.map(|it| it.syntax()));
+
+        NavigationTarget::from_syntax(
+            frange.file_id,
+            name,
+            None,
+            frange.range,
+            node.value.syntax().kind(),
+        )
+    }
+
     fn from_syntax(
         file_id: FileId,
         name: SmolStr,
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index fc57dc33d..8105ef373 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -171,7 +171,15 @@ fn runnable_fn(
     let cfg_exprs =
         attrs.by_key("cfg").tt_values().map(|subtree| ra_cfg::parse_cfg(subtree)).collect();
 
-    let nav = NavigationTarget::from_named(sema.db, InFile::new(file_id.into(), &fn_def));
+    let nav = if let RunnableKind::DocTest { .. } = kind {
+        NavigationTarget::from_doc_commented(
+            sema.db,
+            InFile::new(file_id.into(), &fn_def),
+            InFile::new(file_id.into(), &fn_def),
+        )
+    } else {
+        NavigationTarget::from_named(sema.db, InFile::new(file_id.into(), &fn_def))
+    };
     Some(Runnable { nav, kind, cfg_exprs })
 }
 
@@ -419,9 +427,7 @@ mod tests {
                     full_range: 22..64,
                     name: "foo",
                     kind: FN_DEF,
-                    focus_range: Some(
-                        56..59,
-                    ),
+                    focus_range: None,
                     container_name: None,
                     description: None,
                     docs: None,
@@ -486,9 +492,7 @@ mod tests {
                     full_range: 51..105,
                     name: "foo",
                     kind: FN_DEF,
-                    focus_range: Some(
-                        97..100,
-                    ),
+                    focus_range: None,
                     container_name: None,
                     description: None,
                     docs: None,
diff --git a/crates/ra_ide/src/snapshots/highlight_doctest.html b/crates/ra_ide/src/snapshots/highlight_doctest.html
index f92a0aba5..f61c0daa5 100644
--- a/crates/ra_ide/src/snapshots/highlight_doctest.html
+++ b/crates/ra_ide/src/snapshots/highlight_doctest.html
@@ -39,48 +39,48 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">impl</span> <span class="struct">Foo</span> {
     <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant declaration">bar</span>: <span class="builtin_type">bool</span> = <span class="bool_literal">true</span>;
 
-    <span class="comment">/// Constructs a new `Foo`.</span>
-    <span class="comment">///</span>
-    <span class="comment">/// # Examples</span>
-    <span class="comment">///</span>
-    <span class="comment">/// ```</span>
-    <span class="comment">/// #</span> <span class="attribute">#![</span><span class="function attribute">allow</span><span class="attribute">(unused_mut)]</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span>: <span class="struct">Foo</span> = <span class="struct">Foo</span>::<span class="function">new</span>();
-    <span class="comment">/// ```</span>
+    <span class="comment documentation">/// Constructs a new `Foo`.</span>
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// # Examples</span>
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// ```</span>
+    <span class="comment documentation">/// #</span> <span class="attribute">#![</span><span class="function attribute">allow</span><span class="attribute">(unused_mut)]</span>
+    <span class="comment documentation">/// </span><span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span>: <span class="struct">Foo</span> = <span class="struct">Foo</span>::<span class="function">new</span>();
+    <span class="comment documentation">/// ```</span>
     <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration">new</span>() -&gt; <span class="struct">Foo</span> {
         <span class="struct">Foo</span> { <span class="field">bar</span>: <span class="bool_literal">true</span> }
     }
 
-    <span class="comment">/// `bar` method on `Foo`.</span>
-    <span class="comment">///</span>
-    <span class="comment">/// # Examples</span>
-    <span class="comment">///</span>
-    <span class="comment">/// ```</span>
-    <span class="comment">/// </span><span class="keyword">use</span> <span class="module">x</span>::<span class="module">y</span>;
-    <span class="comment">///</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foo</span> = <span class="struct">Foo</span>::<span class="function">new</span>();
-    <span class="comment">///</span>
-    <span class="comment">/// </span><span class="comment">// calls bar on foo</span>
-    <span class="comment">/// </span><span class="macro">assert!</span>(foo.bar());
-    <span class="comment">///</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">bar</span> = <span class="variable">foo</span>.<span class="field">bar</span> || <span class="struct">Foo</span>::<span class="constant">bar</span>;
-    <span class="comment">///</span>
-    <span class="comment">/// </span><span class="comment">/* multi-line
-    </span><span class="comment">/// </span><span class="comment">       comment */</span>
-    <span class="comment">///</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">multi_line_string</span> = <span class="string_literal">"Foo
-    </span><span class="comment">/// </span><span class="string_literal">  bar
-    </span><span class="comment">/// </span><span class="string_literal">         "</span>;
-    <span class="comment">///</span>
-    <span class="comment">/// ```</span>
-    <span class="comment">///</span>
-    <span class="comment">/// ```rust,no_run</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foobar</span> = <span class="struct">Foo</span>::<span class="function">new</span>().<span class="function">bar</span>();
-    <span class="comment">/// ```</span>
-    <span class="comment">///</span>
-    <span class="comment">/// ```sh</span>
-    <span class="comment">/// echo 1</span>
-    <span class="comment">/// ```</span>
+    <span class="comment documentation">/// `bar` method on `Foo`.</span>
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// # Examples</span>
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// ```</span>
+    <span class="comment documentation">/// </span><span class="keyword">use</span> <span class="module">x</span>::<span class="module">y</span>;
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// </span><span class="keyword">let</span> <span class="variable declaration">foo</span> = <span class="struct">Foo</span>::<span class="function">new</span>();
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// </span><span class="comment">// calls bar on foo</span>
+    <span class="comment documentation">/// </span><span class="macro">assert!</span>(foo.bar());
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// </span><span class="keyword">let</span> <span class="variable declaration">bar</span> = <span class="variable">foo</span>.<span class="field">bar</span> || <span class="struct">Foo</span>::<span class="constant">bar</span>;
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// </span><span class="comment">/* multi-line
+    </span><span class="comment documentation">/// </span><span class="comment">       comment */</span>
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// </span><span class="keyword">let</span> <span class="variable declaration">multi_line_string</span> = <span class="string_literal">"Foo
+    </span><span class="comment documentation">/// </span><span class="string_literal">  bar
+    </span><span class="comment documentation">/// </span><span class="string_literal">         "</span>;
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// ```</span>
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// ```rust,no_run</span>
+    <span class="comment documentation">/// </span><span class="keyword">let</span> <span class="variable declaration">foobar</span> = <span class="struct">Foo</span>::<span class="function">new</span>().<span class="function">bar</span>();
+    <span class="comment documentation">/// ```</span>
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// ```sh</span>
+    <span class="comment documentation">/// echo 1</span>
+    <span class="comment documentation">/// ```</span>
     <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration">foo</span>(&<span class="self_keyword">self</span>) -&gt; <span class="builtin_type">bool</span> {
         <span class="bool_literal">true</span>
     }
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 854b6cc6d..f8f790e59 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -489,7 +489,14 @@ fn highlight_element(
         }
 
         // Simple token-based highlighting
-        COMMENT => HighlightTag::Comment.into(),
+        COMMENT => {
+            let comment = element.into_token().and_then(ast::Comment::cast)?;
+            let h = HighlightTag::Comment;
+            match comment.kind().doc {
+                Some(_) => h | HighlightModifier::Documentation,
+                None => h.into(),
+            }
+        }
         STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => HighlightTag::StringLiteral.into(),
         ATTR => HighlightTag::Attribute.into(),
         INT_NUMBER | FLOAT_NUMBER => HighlightTag::NumericLiteral.into(),
diff --git a/crates/ra_ide/src/syntax_highlighting/injection.rs b/crates/ra_ide/src/syntax_highlighting/injection.rs
index 929a5cc5c..415f24a6d 100644
--- a/crates/ra_ide/src/syntax_highlighting/injection.rs
+++ b/crates/ra_ide/src/syntax_highlighting/injection.rs
@@ -7,7 +7,10 @@ use hir::Semantics;
 use ra_syntax::{ast, AstToken, SyntaxNode, SyntaxToken, TextRange, TextSize};
 use stdx::SepBy;
 
-use crate::{call_info::ActiveParameter, Analysis, HighlightTag, HighlightedRange, RootDatabase};
+use crate::{
+    call_info::ActiveParameter, Analysis, HighlightModifier, HighlightTag, HighlightedRange,
+    RootDatabase,
+};
 
 use super::HighlightedRangeStack;
 
@@ -118,7 +121,7 @@ pub(super) fn extract_doc_comments(
                     range.start(),
                     range.start() + TextSize::try_from(pos).unwrap(),
                 ),
-                highlight: HighlightTag::Comment.into(),
+                highlight: HighlightTag::Comment | HighlightModifier::Documentation,
                 binding_hash: None,
             });
             line_start += range.len() - TextSize::try_from(pos).unwrap();
@@ -164,6 +167,7 @@ pub(super) fn highlight_doc_comment(
                 h.range.start() + start_offset,
                 h.range.end() + end_offset.unwrap_or(start_offset),
             );
+
             stack.add(h);
         }
     }
diff --git a/crates/ra_ide/src/syntax_highlighting/tags.rs b/crates/ra_ide/src/syntax_highlighting/tags.rs
index 400d22fb6..93bbb4b4d 100644
--- a/crates/ra_ide/src/syntax_highlighting/tags.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tags.rs
@@ -56,6 +56,7 @@ pub enum HighlightModifier {
     /// `foo` in `fn foo(x: i32)` is a definition, `foo` in `foo(90 + 2)` is
     /// not.
     Definition,
+    Documentation,
     Mutable,
     Unsafe,
 }
@@ -108,6 +109,7 @@ impl HighlightModifier {
         HighlightModifier::Attribute,
         HighlightModifier::ControlFlow,
         HighlightModifier::Definition,
+        HighlightModifier::Documentation,
         HighlightModifier::Mutable,
         HighlightModifier::Unsafe,
     ];
@@ -117,6 +119,7 @@ impl HighlightModifier {
             HighlightModifier::Attribute => "attribute",
             HighlightModifier::ControlFlow => "control",
             HighlightModifier::Definition => "declaration",
+            HighlightModifier::Documentation => "documentation",
             HighlightModifier::Mutable => "mutable",
             HighlightModifier::Unsafe => "unsafe",
         }
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index ca95d776a..1527c9947 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -18,7 +18,7 @@ use ra_vfs::{LineEndings, RootEntry, Vfs, VfsChange, VfsFile, VfsTask, Watch};
 use stdx::format_to;
 
 use crate::{
-    config::Config,
+    config::{Config, FilesWatcher},
     diagnostics::{CheckFixes, DiagnosticCollection},
     main_loop::pending_requests::{CompletedRequest, LatestRequests},
     to_proto::url_from_abs_path,
@@ -76,7 +76,6 @@ impl GlobalState {
         workspaces: Vec<ProjectWorkspace>,
         lru_capacity: Option<usize>,
         exclude_globs: &[Glob],
-        watch: Watch,
         config: Config,
     ) -> GlobalState {
         let mut change = AnalysisChange::new();
@@ -111,6 +110,7 @@ impl GlobalState {
 
         let (task_sender, task_receiver) = unbounded();
         let task_sender = Box::new(move |t| task_sender.send(t).unwrap());
+        let watch = Watch(matches!(config.files.watcher, FilesWatcher::Notify));
         let (mut vfs, vfs_roots) = Vfs::new(roots, task_sender, watch);
 
         let mut extern_source_roots = FxHashMap::default();
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 08b0a5a16..f0aaaa21e 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -27,7 +27,7 @@ use ra_flycheck::{CheckTask, Status};
 use ra_ide::{Canceled, FileId, LineIndex};
 use ra_prof::profile;
 use ra_project_model::{PackageRoot, ProjectWorkspace};
-use ra_vfs::{VfsTask, Watch};
+use ra_vfs::VfsTask;
 use rustc_hash::FxHashSet;
 use serde::{de::DeserializeOwned, Serialize};
 use threadpool::ThreadPool;
@@ -160,13 +160,7 @@ pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
             connection.sender.send(request.into()).unwrap();
         }
 
-        GlobalState::new(
-            workspaces,
-            config.lru_capacity,
-            &globs,
-            Watch(matches!(config.files.watcher, FilesWatcher::Notify)),
-            config,
-        )
+        GlobalState::new(workspaces, config.lru_capacity, &globs, config)
     };
 
     loop_state.roots_total = global_state.vfs.read().n_roots();
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 055c97455..ec153097e 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -331,6 +331,7 @@ fn semantic_token_type_and_modifiers(
         let modifier = match modifier {
             HighlightModifier::Attribute => semantic_tokens::ATTRIBUTE_MODIFIER,
             HighlightModifier::Definition => lsp_types::SemanticTokenModifier::DECLARATION,
+            HighlightModifier::Documentation => lsp_types::SemanticTokenModifier::DOCUMENTATION,
             HighlightModifier::ControlFlow => semantic_tokens::CONTROL_FLOW,
             HighlightModifier::Mutable => semantic_tokens::MUTABLE,
             HighlightModifier::Unsafe => semantic_tokens::UNSAFE,
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index c0356344c..f2ff0e435 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -1,5 +1,4 @@
 //! Missing batteries for standard libraries.
-
 use std::{cell::Cell, fmt, time::Instant};
 
 #[inline(always)]
diff --git a/crates/vfs/src/file_set.rs b/crates/vfs/src/file_set.rs
index 7dc721f7e..724606a3d 100644
--- a/crates/vfs/src/file_set.rs
+++ b/crates/vfs/src/file_set.rs
@@ -2,7 +2,7 @@
 //!
 //! Files which do not belong to any explicitly configured `FileSet` belong to
 //! the default `FileSet`.
-use std::{cmp, fmt, iter};
+use std::{fmt, iter};
 
 use paths::AbsPathBuf;
 use rustc_hash::FxHashMap;
@@ -44,6 +44,12 @@ pub struct FileSetConfig {
     roots: Vec<(AbsPathBuf, usize)>,
 }
 
+impl Default for FileSetConfig {
+    fn default() -> Self {
+        FileSetConfig::builder().build()
+    }
+}
+
 impl FileSetConfig {
     pub fn builder() -> FileSetConfigBuilder {
         FileSetConfigBuilder::default()
@@ -60,14 +66,19 @@ impl FileSetConfig {
         self.n_file_sets
     }
     fn classify(&self, path: &VfsPath) -> usize {
-        for (root, idx) in self.roots.iter() {
-            if let Some(path) = path.as_path() {
-                if path.starts_with(root) {
-                    return *idx;
-                }
-            }
+        let path = match path.as_path() {
+            Some(it) => it,
+            None => return self.len() - 1,
+        };
+        let idx = match self.roots.binary_search_by(|(p, _)| p.as_path().cmp(path)) {
+            Ok(it) => it,
+            Err(it) => it.saturating_sub(1),
+        };
+        if path.starts_with(&self.roots[idx].0) {
+            self.roots[idx].1
+        } else {
+            self.len() - 1
         }
-        self.len() - 1
     }
 }
 
@@ -82,6 +93,9 @@ impl Default for FileSetConfigBuilder {
 }
 
 impl FileSetConfigBuilder {
+    pub fn len(&self) -> usize {
+        self.roots.len()
+    }
     pub fn add_file_set(&mut self, roots: Vec<AbsPathBuf>) {
         self.roots.push(roots)
     }
@@ -93,7 +107,7 @@ impl FileSetConfigBuilder {
             .enumerate()
             .flat_map(|(i, paths)| paths.into_iter().zip(iter::repeat(i)))
             .collect();
-        roots.sort_by_key(|(path, _)| cmp::Reverse(path.to_string_lossy().len()));
+        roots.sort();
         FileSetConfig { n_file_sets, roots }
     }
 }
diff --git a/crates/vfs/src/lib.rs b/crates/vfs/src/lib.rs
index 75ce61cf9..055219b0c 100644
--- a/crates/vfs/src/lib.rs
+++ b/crates/vfs/src/lib.rs
@@ -79,6 +79,9 @@ pub enum ChangeKind {
 }
 
 impl Vfs {
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
     pub fn file_id(&self, path: &VfsPath) -> Option<FileId> {
         self.interner.get(path).filter(|&it| self.get(it).is_some())
     }