4 files changed, 59 insertions, 38 deletions

diff --git a/crates/ra_ide/src/change.rs b/crates/ra_ide/src/change.rs
index 45a58690b..18dad2ea3 100644
--- a/crates/ra_ide/src/change.rs
+++ b/crates/ra_ide/src/change.rs
@@ -145,6 +145,8 @@ impl LibraryData {
         root_id: SourceRootId,
         files: Vec<(FileId, RelativePathBuf, Arc<String>)>,
     ) -> LibraryData {
+        let _p = profile("LibraryData::prepare");
+
         #[cfg(not(feature = "wasm"))]
         let iter = files.par_iter();
         #[cfg(feature = "wasm")]
diff --git a/crates/ra_ide/src/completion/complete_scope.rs b/crates/ra_ide/src/completion/complete_scope.rs
index 458d7525e..64b04ec2b 100644
--- a/crates/ra_ide/src/completion/complete_scope.rs
+++ b/crates/ra_ide/src/completion/complete_scope.rs
@@ -6,6 +6,7 @@ use ra_text_edit::TextEditBuilder;
 use rustc_hash::FxHashMap;
 
 use crate::completion::{CompletionContext, CompletionItem, CompletionKind, Completions};
+use hir::{ModPath, PathKind};
 
 pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.is_trivial_path {
@@ -54,58 +55,76 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
     }
 }
 
-fn build_import_label(name: &str, path: &[SmolStr]) -> String {
+fn build_import_label(name: &str, path: &ModPath) -> String {
     let mut buf = String::with_capacity(64);
     buf.push_str(name);
     buf.push_str(" (");
-    fmt_import_path(path, &mut buf);
+    buf.push_str(&path.to_string());
     buf.push_str(")");
     buf
 }
 
-fn fmt_import_path(path: &[SmolStr], buf: &mut String) {
-    let mut segments = path.iter();
-    if let Some(s) = segments.next() {
-        buf.push_str(&s);
-    }
-    for s in segments {
-        buf.push_str("::");
-        buf.push_str(&s);
-    }
-}
-
 #[derive(Debug, Clone, Default)]
 pub(crate) struct ImportResolver {
     // todo: use fst crate or something like that
-    dummy_names: Vec<(SmolStr, Vec<SmolStr>)>,
+    dummy_names: Vec<(SmolStr, ModPath)>,
 }
 
 impl ImportResolver {
     pub(crate) fn new() -> Self {
+        use hir::name;
+
         let dummy_names = vec![
-            (SmolStr::new("fmt"), vec![SmolStr::new("std"), SmolStr::new("fmt")]),
-            (SmolStr::new("io"), vec![SmolStr::new("std"), SmolStr::new("io")]),
-            (SmolStr::new("iter"), vec![SmolStr::new("std"), SmolStr::new("iter")]),
-            (SmolStr::new("hash"), vec![SmolStr::new("std"), SmolStr::new("hash")]),
+            (
+                SmolStr::new("fmt"),
+                ModPath { kind: PathKind::Plain, segments: vec![name![std], name![fmt]] },
+            ),
+            (
+                SmolStr::new("io"),
+                ModPath { kind: PathKind::Plain, segments: vec![name![std], name![io]] },
+            ),
+            (
+                SmolStr::new("iter"),
+                ModPath { kind: PathKind::Plain, segments: vec![name![std], name![iter]] },
+            ),
+            (
+                SmolStr::new("hash"),
+                ModPath { kind: PathKind::Plain, segments: vec![name![std], name![hash]] },
+            ),
             (
                 SmolStr::new("Debug"),
-                vec![SmolStr::new("std"), SmolStr::new("fmt"), SmolStr::new("Debug")],
+                ModPath {
+                    kind: PathKind::Plain,
+                    segments: vec![name![std], name![fmt], name![Debug]],
+                },
             ),
             (
                 SmolStr::new("Display"),
-                vec![SmolStr::new("std"), SmolStr::new("fmt"), SmolStr::new("Display")],
+                ModPath {
+                    kind: PathKind::Plain,
+                    segments: vec![name![std], name![fmt], name![Display]],
+                },
             ),
             (
                 SmolStr::new("Hash"),
-                vec![SmolStr::new("std"), SmolStr::new("hash"), SmolStr::new("Hash")],
+                ModPath {
+                    kind: PathKind::Plain,
+                    segments: vec![name![std], name![hash], name![Hash]],
+                },
             ),
             (
                 SmolStr::new("Hasher"),
-                vec![SmolStr::new("std"), SmolStr::new("hash"), SmolStr::new("Hasher")],
+                ModPath {
+                    kind: PathKind::Plain,
+                    segments: vec![name![std], name![hash], name![Hasher]],
+                },
             ),
             (
                 SmolStr::new("Iterator"),
-                vec![SmolStr::new("std"), SmolStr::new("iter"), SmolStr::new("Iterator")],
+                ModPath {
+                    kind: PathKind::Plain,
+                    segments: vec![name![std], name![iter], name![Iterator]],
+                },
             ),
         ];
 
@@ -115,7 +134,7 @@ impl ImportResolver {
     // Returns a map of importable items filtered by name.
     // The map associates item name with its full path.
     // todo: should return Resolutions
-    pub(crate) fn all_names(&self, name: &str) -> FxHashMap<SmolStr, Vec<SmolStr>> {
+    pub(crate) fn all_names(&self, name: &str) -> FxHashMap<SmolStr, ModPath> {
         if name.len() > 1 {
             self.dummy_names.iter().filter(|(n, _)| n.contains(name)).cloned().collect()
         } else {
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 393ca9447..de447a5aa 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -376,7 +376,7 @@ fn main() {
     let mut start = 0;
     (0..2).for_each(|increment| {
         start += increment;
-    })
+    });
 
     let multiply = |a, b, c, d| a * b * c * d;
     let _: i32 = multiply(1, 2, 3, 4);
@@ -399,37 +399,37 @@ fn main() {
                 label: "i32",
             },
             InlayHint {
-                range: [114; 122),
+                range: [115; 123),
                 kind: TypeHint,
                 label: "|…| -> i32",
             },
             InlayHint {
-                range: [126; 127),
+                range: [127; 128),
                 kind: TypeHint,
                 label: "i32",
             },
             InlayHint {
-                range: [129; 130),
+                range: [130; 131),
                 kind: TypeHint,
                 label: "i32",
             },
             InlayHint {
-                range: [132; 133),
+                range: [133; 134),
                 kind: TypeHint,
                 label: "i32",
             },
             InlayHint {
-                range: [135; 136),
+                range: [136; 137),
                 kind: TypeHint,
                 label: "i32",
             },
             InlayHint {
-                range: [200; 212),
+                range: [201; 213),
                 kind: TypeHint,
                 label: "&|…| -> i32",
             },
             InlayHint {
-                range: [235; 244),
+                range: [236; 245),
                 kind: TypeHint,
                 label: "|| -> i32",
             },
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index 626efb603..9a84c1c88 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -2,7 +2,9 @@
 
 use hir::ModuleSource;
 use ra_db::{RelativePath, RelativePathBuf, SourceDatabase, SourceDatabaseExt};
-use ra_syntax::{algo::find_node_at_offset, ast, tokenize, AstNode, SyntaxKind, SyntaxNode};
+use ra_syntax::{
+    algo::find_node_at_offset, ast, lex_single_valid_syntax_kind, AstNode, SyntaxKind, SyntaxNode,
+};
 use ra_text_edit::TextEdit;
 
 use crate::{
@@ -17,11 +19,9 @@ pub(crate) fn rename(
     position: FilePosition,
     new_name: &str,
 ) -> Option<RangeInfo<SourceChange>> {
-    let tokens = tokenize(new_name);
-    if tokens.len() != 1
-        || (tokens[0].kind != SyntaxKind::IDENT && tokens[0].kind != SyntaxKind::UNDERSCORE)
-    {
-        return None;
+    match lex_single_valid_syntax_kind(new_name)? {
+        SyntaxKind::IDENT | SyntaxKind::UNDERSCORE => (),
+        _ => return None,
     }
 
     let parse = db.parse(position.file_id);