2 files changed, 101 insertions, 68 deletions

diff --git a/crates/server/src/main_loop/handlers.rs b/crates/server/src/main_loop/handlers.rs
index 9de6f480b..637bf1b24 100644
--- a/crates/server/src/main_loop/handlers.rs
+++ b/crates/server/src/main_loop/handlers.rs
@@ -11,27 +11,29 @@ use libsyntax2::TextUnit;
 use serde_json::{to_value, from_value};
 
 use ::{
+    PathMap,
     req::{self, Decoration}, Result,
-    util::FilePath,
-    conv::{Conv, ConvWith, TryConvWith, MapConvWith},
+    conv::{Conv, ConvWith, TryConvWith, MapConvWith, to_location},
 };
 
 pub fn handle_syntax_tree(
     world: World,
+    path_map: PathMap,
     params: req::SyntaxTreeParams,
 ) -> Result<String> {
-    let path = params.text_document.file_path()?;
-    let file = world.file_syntax(&path)?;
+    let id = params.text_document.try_conv_with(&path_map)?;
+    let file = world.file_syntax(id)?;
     Ok(libeditor::syntax_tree(&file))
 }
 
 pub fn handle_extend_selection(
     world: World,
+    path_map: PathMap,
     params: req::ExtendSelectionParams,
 ) -> Result<req::ExtendSelectionResult> {
-    let path = params.text_document.file_path()?;
-    let file = world.file_syntax(&path)?;
-    let line_index = world.file_line_index(&path)?;
+    let file_id = params.text_document.try_conv_with(&path_map)?;
+    let file = world.file_syntax(file_id)?;
+    let line_index = world.file_line_index(file_id)?;
     let selections = params.selections.into_iter()
         .map_conv_with(&line_index)
         .map(|r| libeditor::extend_selection(&file, r).unwrap_or(r))
@@ -42,11 +44,12 @@ pub fn handle_extend_selection(
 
 pub fn handle_document_symbol(
     world: World,
+    path_map: PathMap,
     params: req::DocumentSymbolParams,
 ) -> Result<Option<req::DocumentSymbolResponse>> {
-    let path = params.text_document.file_path()?;
-    let file = world.file_syntax(&path)?;
-    let line_index = world.file_line_index(&path)?;
+    let file_id = params.text_document.try_conv_with(&path_map)?;
+    let file = world.file_syntax(file_id)?;
+    let line_index = world.file_line_index(file_id)?;
 
     let mut parents: Vec<(DocumentSymbol, Option<usize>)> = Vec::new();
 
@@ -81,11 +84,12 @@ pub fn handle_document_symbol(
 
 pub fn handle_code_action(
     world: World,
+    path_map: PathMap,
     params: req::CodeActionParams,
 ) -> Result<Option<Vec<Command>>> {
-    let path = params.text_document.file_path()?;
-    let file = world.file_syntax(&path)?;
-    let line_index = world.file_line_index(&path)?;
+    let file_id = params.text_document.try_conv_with(&path_map)?;
+    let file = world.file_syntax(file_id)?;
+    let line_index = world.file_line_index(file_id)?;
     let offset = params.range.conv_with(&line_index).start();
     let mut ret = Vec::new();
 
@@ -105,6 +109,7 @@ pub fn handle_code_action(
 
 pub fn handle_workspace_symbol(
     world: World,
+    path_map: PathMap,
     params: req::WorkspaceSymbolParams,
 ) -> Result<Option<Vec<SymbolInformation>>> {
     let all_symbols = params.query.contains("#");
@@ -119,23 +124,26 @@ pub fn handle_workspace_symbol(
         q.limit(128);
         q
     };
-    let mut res = exec_query(&world, query)?;
+    let mut res = exec_query(&world, &path_map, query)?;
     if res.is_empty() && !all_symbols {
         let mut query = Query::new(params.query);
         query.limit(128);
-        res = exec_query(&world, query)?;
+        res = exec_query(&world, &path_map, query)?;
     }
 
     return Ok(Some(res));
 
-    fn exec_query(world: &World, query: Query) -> Result<Vec<SymbolInformation>> {
+    fn exec_query(world: &World, path_map: &PathMap, query: Query) -> Result<Vec<SymbolInformation>> {
         let mut res = Vec::new();
-        for (path, symbol) in world.world_symbols(query) {
-            let line_index = world.file_line_index(path)?;
+        for (file_id, symbol) in world.world_symbols(query) {
+            let line_index = world.file_line_index(file_id)?;
             let info = SymbolInformation {
                 name: symbol.name.to_string(),
                 kind: symbol.kind.conv(),
-                location: (path, symbol.node_range).try_conv_with(&line_index)?,
+                location: to_location(
+                    file_id, symbol.node_range,
+                    path_map, &line_index
+                )?,
                 container_name: None,
             };
             res.push(info);
@@ -146,15 +154,19 @@ pub fn handle_workspace_symbol(
 
 pub fn handle_goto_definition(
     world: World,
+    path_map: PathMap,
     params: req::TextDocumentPositionParams,
 ) -> Result<Option<req::GotoDefinitionResponse>> {
-    let path = params.text_document.file_path()?;
-    let line_index = world.file_line_index(&path)?;
+    let file_id = params.text_document.try_conv_with(&path_map)?;
+    let line_index = world.file_line_index(file_id)?;
     let offset = params.position.conv_with(&line_index);
     let mut res = Vec::new();
-    for (path, symbol) in world.approximately_resolve_symbol(&path, offset)? {
-        let line_index = world.file_line_index(path)?;
-        let location = (path, symbol.node_range).try_conv_with(&line_index)?;
+    for (file_id, symbol) in world.approximately_resolve_symbol(file_id, offset)? {
+        let line_index = world.file_line_index(file_id)?;
+        let location = to_location(
+            file_id, symbol.node_range,
+            &path_map, &line_index,
+        )?;
         res.push(location)
     }
     Ok(Some(req::GotoDefinitionResponse::Array(res)))
@@ -162,6 +174,7 @@ pub fn handle_goto_definition(
 
 pub fn handle_execute_command(
     world: World,
+    path_map: PathMap,
     mut params: req::ExecuteCommandParams,
 ) -> Result<req::ApplyWorkspaceEditParams> {
     if params.command.as_str() != "apply_code_action" {
@@ -172,8 +185,8 @@ pub fn handle_execute_command(
     }
     let arg = params.arguments.pop().unwrap();
     let arg: ActionRequest = from_value(arg)?;
-    let path = arg.text_document.file_path()?;
-    let file = world.file_syntax(&path)?;
+    let file_id = arg.text_document.try_conv_with(&path_map)?;
+    let file = world.file_syntax(file_id)?;
     let edit = match arg.id {
         ActionId::FlipComma => libeditor::flip_comma(&file, arg.offset).map(|edit| edit()),
         ActionId::AddDerive => libeditor::add_derive(&file, arg.offset).map(|edit| edit()),
@@ -182,7 +195,7 @@ pub fn handle_execute_command(
         Some(edit) => edit,
         None => bail!("command not applicable"),
     };
-    let line_index = world.file_line_index(&path)?;
+    let line_index = world.file_line_index(file_id)?;
     let mut changes = HashMap::new();
     changes.insert(
         arg.text_document.uri,
@@ -231,10 +244,14 @@ impl ActionId {
     }
 }
 
-pub fn publish_diagnostics(world: World, uri: Url) -> Result<req::PublishDiagnosticsParams> {
-    let path = uri.file_path()?;
-    let file = world.file_syntax(&path)?;
-    let line_index = world.file_line_index(&path)?;
+pub fn publish_diagnostics(
+    world: World,
+    path_map: PathMap,
+    uri: Url
+) -> Result<req::PublishDiagnosticsParams> {
+    let file_id = uri.try_conv_with(&path_map)?;
+    let file = world.file_syntax(file_id)?;
+    let line_index = world.file_line_index(file_id)?;
     let diagnostics = libeditor::diagnostics(&file)
         .into_iter()
         .map(|d| Diagnostic {
@@ -248,10 +265,14 @@ pub fn publish_diagnostics(world: World, uri: Url) -> Result<req::PublishDiagnos
     Ok(req::PublishDiagnosticsParams { uri, diagnostics })
 }
 
-pub fn publish_decorations(world: World, uri: Url) -> Result<req::PublishDecorationsParams> {
-    let path = uri.file_path()?;
-    let file = world.file_syntax(&path)?;
-    let line_index = world.file_line_index(&path)?;
+pub fn publish_decorations(
+    world: World,
+    path_map: PathMap,
+    uri: Url
+) -> Result<req::PublishDecorationsParams> {
+    let file_id = uri.try_conv_with(&path_map)?;
+    let file = world.file_syntax(file_id)?;
+    let line_index = world.file_line_index(file_id)?;
     let decorations = libeditor::highlight(&file)
         .into_iter()
         .map(|h| Decoration {
diff --git a/crates/server/src/main_loop/mod.rs b/crates/server/src/main_loop/mod.rs
index bc898c17b..2a31297be 100644
--- a/crates/server/src/main_loop/mod.rs
+++ b/crates/server/src/main_loop/mod.rs
@@ -1,22 +1,21 @@
 mod handlers;
 
 use std::{
-    path::PathBuf,
     collections::{HashSet, HashMap},
 };
 
 use threadpool::ThreadPool;
 use crossbeam_channel::{Sender, Receiver};
 use languageserver_types::Url;
-use libanalysis::{World, WorldState};
+use libanalysis::{World, WorldState, FileId};
 use serde_json::to_value;
 
 use {
     req, dispatch,
-    Task, Result,
+    Task, Result, PathMap,
     io::{Io, RawMsg, RawRequest, RawNotification},
-    util::FilePath,
     vfs::{FileEvent, FileEventKind},
+    conv::TryConvWith,
     main_loop::handlers::{
         handle_syntax_tree,
         handle_extend_selection,
@@ -41,7 +40,8 @@ pub(super) fn main_loop(
     info!("server initialized, serving requests");
     let mut next_request_id = 0;
     let mut pending_requests: HashSet<u64> = HashSet::new();
-    let mut mem_map: HashMap<PathBuf, Option<String>> = HashMap::new();
+    let mut path_map = PathMap::new();
+    let mut mem_map: HashMap<FileId, Option<String>> = HashMap::new();
     let mut fs_events_receiver = Some(&fs_events_receiver);
     loop {
         enum Event {
@@ -98,12 +98,15 @@ pub(super) fn main_loop(
                         };
                         (event.path, text)
                     })
-                    .filter_map(|(path, text)| {
-                        if mem_map.contains_key(path.as_path()) {
-                            mem_map.insert(path, text);
+                    .map(|(path, text)| {
+                        (path_map.get_or_insert(path), text)
+                    })
+                    .filter_map(|(id, text)| {
+                        if mem_map.contains_key(&id) {
+                            mem_map.insert(id, text);
                             None
                         } else {
-                            Some((path, text))
+                            Some((id, text))
                         }
                     });
 
@@ -112,12 +115,12 @@ pub(super) fn main_loop(
             Event::Msg(msg) => {
                 match msg {
                     RawMsg::Request(req) => {
-                        if !on_request(io, world, pool, &task_sender, req)? {
+                        if !on_request(io, world, &path_map, pool, &task_sender, req)? {
                             return Ok(());
                         }
                     }
                     RawMsg::Notification(not) => {
-                        on_notification(io, world, pool, &task_sender, not, &mut mem_map)?
+                        on_notification(io, world, &mut path_map, pool, &task_sender, not, &mut mem_map)?
                     }
                     RawMsg::Response(resp) => {
                         if !pending_requests.remove(&resp.id) {
@@ -133,36 +136,38 @@ pub(super) fn main_loop(
 fn on_request(
     io: &mut Io,
     world: &WorldState,
+    path_map: &PathMap,
     pool: &ThreadPool,
     sender: &Sender<Task>,
     req: RawRequest,
 ) -> Result<bool> {
     let mut req = Some(req);
     handle_request_on_threadpool::<req::SyntaxTree>(
-        &mut req, pool, world, sender, handle_syntax_tree,
+        &mut req, pool, path_map, world, sender, handle_syntax_tree,
     )?;
     handle_request_on_threadpool::<req::ExtendSelection>(
-        &mut req, pool, world, sender, handle_extend_selection,
+        &mut req, pool, path_map, world, sender, handle_extend_selection,
     )?;
     handle_request_on_threadpool::<req::DocumentSymbolRequest>(
-        &mut req, pool, world, sender, handle_document_symbol,
+        &mut req, pool, path_map, world, sender, handle_document_symbol,
     )?;
     handle_request_on_threadpool::<req::CodeActionRequest>(
-        &mut req, pool, world, sender, handle_code_action,
+        &mut req, pool, path_map, world, sender, handle_code_action,
     )?;
     handle_request_on_threadpool::<req::WorkspaceSymbol>(
-        &mut req, pool, world, sender, handle_workspace_symbol,
+        &mut req, pool, path_map, world, sender, handle_workspace_symbol,
     )?;
     handle_request_on_threadpool::<req::GotoDefinition>(
-        &mut req, pool, world, sender, handle_goto_definition,
+        &mut req, pool, path_map, world, sender, handle_goto_definition,
     )?;
     dispatch::handle_request::<req::ExecuteCommand, _>(&mut req, |params, resp| {
         io.send(RawMsg::Response(resp.into_response(Ok(None))?));
 
         let world = world.snapshot();
+        let path_map = path_map.clone();
         let sender = sender.clone();
         pool.execute(move || {
-            let task = match handle_execute_command(world, params) {
+            let task = match handle_execute_command(world, path_map, params) {
                 Ok(req) => match to_value(req) {
                     Err(e) => Task::Die(e.into()),
                     Ok(params) => {
@@ -202,39 +207,43 @@ fn on_request(
 fn on_notification(
     io: &mut Io,
     world: &mut WorldState,
+    path_map: &mut PathMap,
     pool: &ThreadPool,
     sender: &Sender<Task>,
     not: RawNotification,
-    mem_map: &mut HashMap<PathBuf, Option<String>>,
+    mem_map: &mut HashMap<FileId, Option<String>>,
 ) -> Result<()> {
     let mut not = Some(not);
     dispatch::handle_notification::<req::DidOpenTextDocument, _>(&mut not, |params| {
-        let path = params.text_document.file_path()?;
-        mem_map.insert(path.clone(), None);
-        world.change_file(path, Some(params.text_document.text));
+        let uri = params.text_document.uri;
+        let path = uri.to_file_path()
+            .map_err(|()| format_err!("invalid uri: {}", uri))?;
+        let file_id = path_map.get_or_insert(path);
+        mem_map.insert(file_id, None);
+        world.change_file(file_id, Some(params.text_document.text));
         update_file_notifications_on_threadpool(
-            pool, world.snapshot(), sender.clone(), params.text_document.uri,
+            pool, world.snapshot(), path_map.clone(), sender.clone(), uri,
         );
         Ok(())
     })?;
     dispatch::handle_notification::<req::DidChangeTextDocument, _>(&mut not, |mut params| {
-        let path = params.text_document.file_path()?;
+        let file_id = params.text_document.try_conv_with(path_map)?;
         let text = params.content_changes.pop()
             .ok_or_else(|| format_err!("empty changes"))?
             .text;
-        world.change_file(path, Some(text));
+        world.change_file(file_id, Some(text));
         update_file_notifications_on_threadpool(
-            pool, world.snapshot(), sender.clone(), params.text_document.uri,
+            pool, world.snapshot(), path_map.clone(), sender.clone(), params.text_document.uri,
         );
         Ok(())
     })?;
     dispatch::handle_notification::<req::DidCloseTextDocument, _>(&mut not, |params| {
-        let path = params.text_document.file_path()?;
-        let text = match mem_map.remove(&path) {
+        let file_id = params.text_document.try_conv_with(path_map)?;
+        let text = match mem_map.remove(&file_id) {
             Some(text) => text,
             None => bail!("unmatched close notification"),
         };
-        world.change_file(path, text);
+        world.change_file(file_id, text);
         let not = req::PublishDiagnosticsParams {
             uri: params.text_document.uri,
             diagnostics: Vec::new(),
@@ -253,16 +262,18 @@ fn on_notification(
 fn handle_request_on_threadpool<R: req::ClientRequest>(
     req: &mut Option<RawRequest>,
     pool: &ThreadPool,
+    path_map: &PathMap,
     world: &WorldState,
     sender: &Sender<Task>,
-    f: fn(World, R::Params) -> Result<R::Result>,
+    f: fn(World, PathMap, R::Params) -> Result<R::Result>,
 ) -> Result<()>
 {
     dispatch::handle_request::<R, _>(req, |params, resp| {
         let world = world.snapshot();
+        let path_map = path_map.clone();
         let sender = sender.clone();
         pool.execute(move || {
-            let res = f(world, params);
+            let res = f(world, path_map, params);
             let task = match resp.into_response(res) {
                 Ok(resp) => Task::Respond(resp),
                 Err(e) => Task::Die(e),
@@ -276,11 +287,12 @@ fn handle_request_on_threadpool<R: req::ClientRequest>(
 fn update_file_notifications_on_threadpool(
     pool: &ThreadPool,
     world: World,
+    path_map: PathMap,
     sender: Sender<Task>,
     uri: Url,
 ) {
     pool.execute(move || {
-        match publish_diagnostics(world.clone(), uri.clone()) {
+        match publish_diagnostics(world.clone(), path_map.clone(), uri.clone()) {
             Err(e) => {
                 error!("failed to compute diagnostics: {:?}", e)
             }
@@ -289,7 +301,7 @@ fn update_file_notifications_on_threadpool(
                 sender.send(Task::Notify(not));
             }
         }
-        match publish_decorations(world, uri) {
+        match publish_decorations(world, path_map.clone(), uri) {
             Err(e) => {
                 error!("failed to compute decorations: {:?}", e)
             }