2 files changed, 59 insertions, 8 deletions

diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index c872b0dc4..6d5622b15 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -9,7 +9,7 @@ use languageserver_types::{
     WorkspaceEdit, ParameterInformation, SignatureInformation, Hover, HoverContents,
 };
 use ra_analysis::{FileId, FoldKind, Query, RunnableKind, FilePosition};
-use ra_syntax::text_utils::contains_offset_nonstrict;
+use ra_syntax::{TextUnit, text_utils::contains_offset_nonstrict};
 use rustc_hash::FxHashMap;
 use serde_json::to_value;
 
@@ -381,6 +381,28 @@ pub fn handle_completion(
         let offset = params.position.conv_with(&line_index);
         FilePosition { file_id, offset }
     };
+    let completion_triggered_after_single_colon = {
+        let mut res = false;
+        if let Some(ctx) = params.context {
+            if ctx.trigger_character.unwrap_or_default() == ":" {
+                let source_file = world.analysis().file_syntax(position.file_id);
+                let syntax = source_file.syntax();
+                let text = syntax.text();
+                if let Some(next_char) = text.char_at(position.offset) {
+                    let diff = TextUnit::of_char(next_char) + TextUnit::of_char(':');
+                    let prev_char = position.offset - diff;
+                    if text.char_at(prev_char) != Some(':') {
+                        res = true;
+                    }
+                }
+            }
+        }
+        res
+    };
+    if completion_triggered_after_single_colon {
+        return Ok(None);
+    }
+
     let items = match world.analysis().completions(position)? {
         None => return Ok(None),
         Some(items) => items,
@@ -545,10 +567,13 @@ pub fn handle_rename(world: ServerWorld, params: RenameParams) -> Result<Option<
     let mut changes = HashMap::new();
     for r in refs {
         if let Ok(loc) = to_location(r.0, r.1, &world, &line_index) {
-            changes.entry(loc.uri).or_insert(Vec::new()).push(TextEdit {
-                range: loc.range,
-                new_text: params.new_name.clone(),
-            });
+            changes
+                .entry(loc.uri)
+                .or_insert_with(Vec::new)
+                .push(TextEdit {
+                    range: loc.range,
+                    new_text: params.new_name.clone(),
+                });
         }
     }
 
diff --git a/crates/ra_lsp_server/src/main_loop/mod.rs b/crates/ra_lsp_server/src/main_loop/mod.rs
index 78d93741a..36f08be2f 100644
--- a/crates/ra_lsp_server/src/main_loop/mod.rs
+++ b/crates/ra_lsp_server/src/main_loop/mod.rs
@@ -168,9 +168,35 @@ fn main_loop_inner(
                     let workspaces = vec![ws];
                     feedback(internal_mode, "workspace loaded", msg_sender);
                     for ws in workspaces.iter() {
-                        for pkg in ws.packages().filter(|pkg| !pkg.is_member(ws)) {
-                            debug!("sending root, {}", pkg.root(ws).to_path_buf().display());
-                            fs_worker.send(pkg.root(ws).to_path_buf());
+                        // Add each library as constant input. If library is
+                        // within the workspace, don't treat it as a library.
+                        //
+                        // HACK: If source roots are nested, pick the outer one.
+
+                        let mut roots = ws
+                            .packages()
+                            .filter(|pkg| !pkg.is_member(ws))
+                            .filter_map(|pkg| {
+                                let root = pkg.root(ws).to_path_buf();
+                                if root.starts_with(&ws_root) {
+                                    None
+                                } else {
+                                    Some(root)
+                                }
+                            })
+                            .collect::<Vec<_>>();
+                        roots.sort_by_key(|it| it.as_os_str().len());
+                        let unique = roots
+                            .iter()
+                            .enumerate()
+                            .filter(|&(idx, long)| {
+                                !roots[..idx].iter().any(|short| long.starts_with(short))
+                            })
+                            .map(|(_idx, root)| root);
+
+                        for root in unique {
+                            debug!("sending root, {}", root.display());
+                            fs_worker.send(root.to_owned());
                         }
                     }
                     state.set_workspaces(workspaces);