8 files changed, 145 insertions, 167 deletions

diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index cce959669..09d74b9e7 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,17 +1,20 @@
-use crate::{
-    module_map::{ModuleDescriptorQuery, ModuleTreeQuery, ModulesDatabase},
-    symbol_index::SymbolIndex,
-    FileId, FileResolverImp,
+use std::{
+    fmt,
+    hash::{Hash, Hasher},
+    sync::Arc,
 };
+
 use ra_editor::LineIndex;
 use ra_syntax::File;
 use rustc_hash::FxHashSet;
 use salsa;
 
-use std::{
-    fmt,
-    hash::{Hash, Hasher},
-    sync::Arc,
+use crate::{
+    db,
+    Cancelable, Canceled,
+    module_map::{ModuleDescriptorQuery, ModuleTreeQuery, ModulesDatabase},
+    symbol_index::SymbolIndex,
+    FileId, FileResolverImp,
 };
 
 #[derive(Default)]
@@ -31,6 +34,14 @@ impl salsa::Database for RootDatabase {
     }
 }
 
+pub(crate) fn check_canceled(db: &impl salsa::Database) -> Cancelable<()> {
+    if db.salsa_runtime().is_current_revision_canceled() {
+        Err(Canceled)
+    } else {
+        Ok(())
+    }
+}
+
 impl salsa::ParallelDatabase for RootDatabase {
     fn fork(&self) -> Self {
         RootDatabase {
@@ -98,7 +109,7 @@ salsa::query_group! {
         fn file_lines(file_id: FileId) -> Arc<LineIndex> {
             type FileLinesQuery;
         }
-        fn file_symbols(file_id: FileId) -> Arc<SymbolIndex> {
+        fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
             type FileSymbolsQuery;
         }
     }
@@ -112,7 +123,8 @@ fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<LineIndex> {
     let text = db.file_text(file_id);
     Arc::new(LineIndex::new(&*text))
 }
-fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<SymbolIndex> {
+fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
+    db::check_canceled(db)?;
     let syntax = db.file_syntax(file_id);
-    Arc::new(SymbolIndex::for_file(file_id, syntax))
+    Ok(Arc::new(SymbolIndex::for_file(file_id, syntax)))
 }
diff --git a/crates/ra_analysis/src/descriptors.rs b/crates/ra_analysis/src/descriptors.rs
index 6f26f9935..310bf1585 100644
--- a/crates/ra_analysis/src/descriptors.rs
+++ b/crates/ra_analysis/src/descriptors.rs
@@ -1,4 +1,5 @@
-use crate::{imp::FileResolverImp, FileId};
+use std::collections::BTreeMap;
+
 use ra_syntax::{
     ast::{self, AstNode, NameOwner},
     text_utils::is_subrange,
@@ -6,7 +7,7 @@ use ra_syntax::{
 };
 use relative_path::RelativePathBuf;
 
-use std::collections::BTreeMap;
+use crate::{imp::FileResolverImp, FileId};
 
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct ModuleDescriptor {
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index a67b1717a..32e9bb6d7 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -19,8 +19,8 @@ use rustc_hash::FxHashSet;
 use crate::{
     descriptors::{FnDescriptor, ModuleTreeDescriptor, Problem},
     roots::{ReadonlySourceRoot, SourceRoot, WritableSourceRoot},
-    CrateGraph, CrateId, Diagnostic, FileId, FileResolver, FileSystemEdit, JobToken, Position,
-    Query, SourceChange, SourceFileEdit,
+    CrateGraph, CrateId, Diagnostic, FileId, FileResolver, FileSystemEdit, Position,
+    Query, SourceChange, SourceFileEdit, Cancelable,
 };
 
 #[derive(Clone, Debug)]
@@ -148,19 +148,21 @@ impl AnalysisImpl {
     pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> {
         self.root(file_id).lines(file_id)
     }
-    pub fn world_symbols(&self, query: Query, token: &JobToken) -> Vec<(FileId, FileSymbol)> {
+    pub fn world_symbols(&self, query: Query) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         let mut buf = Vec::new();
         if query.libs {
-            self.data.libs.iter().for_each(|it| it.symbols(&mut buf));
+            for lib in self.data.libs.iter() {
+                lib.symbols(&mut buf)?;
+            }
         } else {
-            self.data.root.symbols(&mut buf);
+            self.data.root.symbols(&mut buf)?;
         }
-        query.search(&buf, token)
+        Ok(query.search(&buf))
     }
-    pub fn parent_module(&self, file_id: FileId) -> Vec<(FileId, FileSymbol)> {
+    pub fn parent_module(&self, file_id: FileId) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         let root = self.root(file_id);
-        let module_tree = root.module_tree();
-        module_tree
+        let module_tree = root.module_tree()?;
+        let res = module_tree
             .parent_modules(file_id)
             .iter()
             .map(|link| {
@@ -174,10 +176,11 @@ impl AnalysisImpl {
                 };
                 (file_id, sym)
             })
-            .collect()
+            .collect();
+        Ok(res)
     }
-    pub fn crate_for(&self, file_id: FileId) -> Vec<CrateId> {
-        let module_tree = self.root(file_id).module_tree();
+    pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
+        let module_tree = self.root(file_id).module_tree()?;
         let crate_graph = &self.data.crate_graph;
         let mut res = Vec::new();
         let mut work = VecDeque::new();
@@ -195,7 +198,7 @@ impl AnalysisImpl {
                 .filter(|&id| visited.insert(id));
             work.extend(parents);
         }
-        res
+        Ok(res)
     }
     pub fn crate_root(&self, crate_id: CrateId) -> FileId {
         self.data.crate_graph.crate_roots[&crate_id]
@@ -204,15 +207,14 @@ impl AnalysisImpl {
         &self,
         file_id: FileId,
         offset: TextUnit,
-        token: &JobToken,
-    ) -> Vec<(FileId, FileSymbol)> {
+    ) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         let root = self.root(file_id);
-        let module_tree = root.module_tree();
+        let module_tree = root.module_tree()?;
         let file = root.syntax(file_id);
         let syntax = file.syntax();
         if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, offset) {
             // First try to resolve the symbol locally
-            if let Some((name, range)) = resolve_local_name(&file, offset, name_ref) {
+            return if let Some((name, range)) = resolve_local_name(&file, offset, name_ref) {
                 let mut vec = vec![];
                 vec.push((
                     file_id,
@@ -222,12 +224,11 @@ impl AnalysisImpl {
                         kind: NAME,
                     },
                 ));
-
-                return vec;
+                Ok(vec)
             } else {
                 // If that fails try the index based approach.
-                return self.index_resolve(name_ref, token);
-            }
+                self.index_resolve(name_ref)
+            };
         }
         if let Some(name) = find_node_at_offset::<ast::Name>(syntax, offset) {
             if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
@@ -250,14 +251,14 @@ impl AnalysisImpl {
                         })
                         .collect();
 
-                    return res;
+                    return Ok(res);
                 }
             }
         }
-        vec![]
+        Ok(vec![])
     }
 
-    pub fn find_all_refs(&self, file_id: FileId, offset: TextUnit, _token: &JobToken) -> Vec<(FileId, TextRange)> {
+    pub fn find_all_refs(&self, file_id: FileId, offset: TextUnit) -> Vec<(FileId, TextRange)> {
         let root = self.root(file_id);
         let file = root.syntax(file_id);
         let syntax = file.syntax();
@@ -289,9 +290,9 @@ impl AnalysisImpl {
         ret
     }
 
-    pub fn diagnostics(&self, file_id: FileId) -> Vec<Diagnostic> {
+    pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
         let root = self.root(file_id);
-        let module_tree = root.module_tree();
+        let module_tree = root.module_tree()?;
         let syntax = root.syntax(file_id);
 
         let mut res = ra_editor::diagnostics(&syntax)
@@ -346,7 +347,7 @@ impl AnalysisImpl {
             };
             res.push(diag)
         }
-        res
+        Ok(res)
     }
 
     pub fn assists(&self, file_id: FileId, range: TextRange) -> Vec<SourceChange> {
@@ -379,18 +380,23 @@ impl AnalysisImpl {
         &self,
         file_id: FileId,
         offset: TextUnit,
-        token: &JobToken,
-    ) -> Option<(FnDescriptor, Option<usize>)> {
+    ) -> Cancelable<Option<(FnDescriptor, Option<usize>)>> {
         let root = self.root(file_id);
         let file = root.syntax(file_id);
         let syntax = file.syntax();
 
         // Find the calling expression and it's NameRef
-        let calling_node = FnCallNode::with_node(syntax, offset)?;
-        let name_ref = calling_node.name_ref()?;
+        let calling_node = match FnCallNode::with_node(syntax, offset) {
+            Some(node) => node,
+            None => return Ok(None),
+        };
+        let name_ref = match calling_node.name_ref() {
+            Some(name) => name,
+            None => return Ok(None),
+        };
 
         // Resolve the function's NameRef (NOTE: this isn't entirely accurate).
-        let file_symbols = self.index_resolve(name_ref, token);
+        let file_symbols = self.index_resolve(name_ref)?;
         for (_, fs) in file_symbols {
             if fs.kind == FN_DEF {
                 if let Some(fn_def) = find_node_at_offset(syntax, fs.node_range.start()) {
@@ -432,21 +438,21 @@ impl AnalysisImpl {
                             }
                         }
 
-                        return Some((descriptor, current_parameter));
+                        return Ok(Some((descriptor, current_parameter)));
                     }
                 }
             }
         }
 
-        None
+        Ok(None)
     }
 
-    fn index_resolve(&self, name_ref: ast::NameRef, token: &JobToken) -> Vec<(FileId, FileSymbol)> {
+    fn index_resolve(&self, name_ref: ast::NameRef) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         let name = name_ref.text();
         let mut query = Query::new(name.to_string());
         query.exact();
         query.limit(4);
-        self.world_symbols(query, token)
+        self.world_symbols(query)
     }
 
     fn resolve_module(
diff --git a/crates/ra_analysis/src/job.rs b/crates/ra_analysis/src/job.rs
deleted file mode 100644
index 2871f9839..000000000
--- a/crates/ra_analysis/src/job.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use crossbeam_channel::{bounded, Receiver, Sender};
-
-pub struct JobHandle {
-    job_alive: Receiver<Never>,
-    _job_canceled: Sender<Never>,
-}
-
-pub struct JobToken {
-    _job_alive: Sender<Never>,
-    job_canceled: Receiver<Never>,
-}
-
-impl JobHandle {
-    pub fn new() -> (JobHandle, JobToken) {
-        let (sender_alive, receiver_alive) = bounded(0);
-        let (sender_canceled, receiver_canceled) = bounded(0);
-        let token = JobToken {
-            _job_alive: sender_alive,
-            job_canceled: receiver_canceled,
-        };
-        let handle = JobHandle {
-            job_alive: receiver_alive,
-            _job_canceled: sender_canceled,
-        };
-        (handle, token)
-    }
-    pub fn has_completed(&self) -> bool {
-        is_closed(&self.job_alive)
-    }
-    pub fn cancel(self) {}
-}
-
-impl JobToken {
-    pub fn is_canceled(&self) -> bool {
-        is_closed(&self.job_canceled)
-    }
-}
-
-// We don't actually send messages through the channels,
-// and instead just check if the channel is closed,
-// so we use uninhabited enum as a message type
-enum Never {}
-
-/// Nonblocking
-fn is_closed(chan: &Receiver<Never>) -> bool {
-    select! {
-        recv(chan, msg) => match msg {
-            None => true,
-            Some(never) => match never {}
-        }
-        default => false,
-    }
-}
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index 46cc0722b..28e0a12b2 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -7,8 +7,6 @@ extern crate ra_editor;
 extern crate ra_syntax;
 extern crate rayon;
 extern crate relative_path;
-#[macro_use]
-extern crate crossbeam_channel;
 extern crate im;
 extern crate rustc_hash;
 extern crate salsa;
@@ -16,27 +14,40 @@ extern crate salsa;
 mod db;
 mod descriptors;
 mod imp;
-mod job;
 mod module_map;
 mod roots;
 mod symbol_index;
 
 use std::{fmt::Debug, sync::Arc};
 
-use crate::imp::{AnalysisHostImpl, AnalysisImpl, FileResolverImp};
 use ra_syntax::{AtomEdit, File, TextRange, TextUnit};
 use relative_path::{RelativePath, RelativePathBuf};
 use rustc_hash::FxHashMap;
 
+use crate::imp::{AnalysisHostImpl, AnalysisImpl, FileResolverImp};
+
 pub use crate::{
     descriptors::FnDescriptor,
-    job::{JobHandle, JobToken},
 };
 pub use ra_editor::{
     CompletionItem, FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, Runnable,
     RunnableKind, StructureNode,
 };
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct Canceled;
+
+pub type Cancelable<T> = Result<T, Canceled>;
+
+impl std::fmt::Display for Canceled {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        fmt.write_str("Canceled")
+    }
+}
+
+impl std::error::Error for Canceled {
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct FileId(pub u32);
 
@@ -205,60 +216,57 @@ impl Analysis {
         let file = self.imp.file_syntax(file_id);
         ra_editor::file_structure(&file)
     }
-    pub fn symbol_search(&self, query: Query, token: &JobToken) -> Vec<(FileId, FileSymbol)> {
-        self.imp.world_symbols(query, token)
+    pub fn folding_ranges(&self, file_id: FileId) -> Vec<Fold> {
+        let file = self.imp.file_syntax(file_id);
+        ra_editor::folding_ranges(&file)
+    }
+    pub fn symbol_search(&self, query: Query) -> Cancelable<Vec<(FileId, FileSymbol)>> {
+        self.imp.world_symbols(query)
     }
     pub fn approximately_resolve_symbol(
         &self,
         file_id: FileId,
-        offset: TextUnit,
-        token: &JobToken,
-    ) -> Vec<(FileId, FileSymbol)> {
+        offset: TextUnit
+    ) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         self.imp
-            .approximately_resolve_symbol(file_id, offset, token)
+            .approximately_resolve_symbol(file_id, offset)
     }
-    pub fn find_all_refs(&self, file_id: FileId, offset: TextUnit, token: &JobToken) -> Vec<(FileId, TextRange)> {
-        self.imp.find_all_refs(file_id, offset, token)
+    pub fn find_all_refs(&self, file_id: FileId, offset: TextUnit, ) -> Cancelable<Vec<(FileId, TextRange)>> {
+        Ok(self.imp.find_all_refs(file_id, offset))
     }
-    pub fn parent_module(&self, file_id: FileId) -> Vec<(FileId, FileSymbol)> {
+    pub fn parent_module(&self, file_id: FileId) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         self.imp.parent_module(file_id)
     }
-    pub fn crate_for(&self, file_id: FileId) -> Vec<CrateId> {
+    pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
         self.imp.crate_for(file_id)
     }
-    pub fn crate_root(&self, crate_id: CrateId) -> FileId {
-        self.imp.crate_root(crate_id)
+    pub fn crate_root(&self, crate_id: CrateId) -> Cancelable<FileId> {
+        Ok(self.imp.crate_root(crate_id))
     }
-    pub fn runnables(&self, file_id: FileId) -> Vec<Runnable> {
+    pub fn runnables(&self, file_id: FileId) -> Cancelable<Vec<Runnable>> {
         let file = self.imp.file_syntax(file_id);
-        ra_editor::runnables(&file)
+        Ok(ra_editor::runnables(&file))
     }
-    pub fn highlight(&self, file_id: FileId) -> Vec<HighlightedRange> {
+    pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
         let file = self.imp.file_syntax(file_id);
-        ra_editor::highlight(&file)
+        Ok(ra_editor::highlight(&file))
     }
-    pub fn completions(&self, file_id: FileId, offset: TextUnit) -> Option<Vec<CompletionItem>> {
+    pub fn completions(&self, file_id: FileId, offset: TextUnit) -> Cancelable<Option<Vec<CompletionItem>>> {
         let file = self.imp.file_syntax(file_id);
-        ra_editor::scope_completion(&file, offset)
+        Ok(ra_editor::scope_completion(&file, offset))
     }
-    pub fn assists(&self, file_id: FileId, range: TextRange) -> Vec<SourceChange> {
-        self.imp.assists(file_id, range)
+    pub fn assists(&self, file_id: FileId, range: TextRange) -> Cancelable<Vec<SourceChange>> {
+        Ok(self.imp.assists(file_id, range))
     }
-    pub fn diagnostics(&self, file_id: FileId) -> Vec<Diagnostic> {
+    pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
         self.imp.diagnostics(file_id)
     }
-    pub fn folding_ranges(&self, file_id: FileId) -> Vec<Fold> {
-        let file = self.imp.file_syntax(file_id);
-        ra_editor::folding_ranges(&file)
-    }
-
     pub fn resolve_callable(
         &self,
         file_id: FileId,
         offset: TextUnit,
-        token: &JobToken,
-    ) -> Option<(FnDescriptor, Option<usize>)> {
-        self.imp.resolve_callable(file_id, offset, token)
+    ) -> Cancelable<Option<(FnDescriptor, Option<usize>)>> {
+        self.imp.resolve_callable(file_id, offset)
     }
 }
 
diff --git a/crates/ra_analysis/src/module_map.rs b/crates/ra_analysis/src/module_map.rs
index b15432498..3c800265a 100644
--- a/crates/ra_analysis/src/module_map.rs
+++ b/crates/ra_analysis/src/module_map.rs
@@ -1,37 +1,41 @@
+use std::sync::Arc;
+
 use crate::{
+    db,
+    Cancelable,
     db::SyntaxDatabase,
     descriptors::{ModuleDescriptor, ModuleTreeDescriptor},
     FileId,
 };
 
-use std::sync::Arc;
-
 salsa::query_group! {
     pub(crate) trait ModulesDatabase: SyntaxDatabase {
-        fn module_tree() -> Arc<ModuleTreeDescriptor> {
+        fn module_tree() -> Cancelable<Arc<ModuleTreeDescriptor>> {
             type ModuleTreeQuery;
         }
-        fn module_descriptor(file_id: FileId) -> Arc<ModuleDescriptor> {
+        fn module_descriptor(file_id: FileId) -> Cancelable<Arc<ModuleDescriptor>> {
             type ModuleDescriptorQuery;
         }
     }
 }
 
-fn module_descriptor(db: &impl ModulesDatabase, file_id: FileId) -> Arc<ModuleDescriptor> {
+fn module_descriptor(db: &impl ModulesDatabase, file_id: FileId) -> Cancelable<Arc<ModuleDescriptor>> {
+    db::check_canceled(db)?;
     let file = db.file_syntax(file_id);
-    Arc::new(ModuleDescriptor::new(file.ast()))
+    Ok(Arc::new(ModuleDescriptor::new(file.ast())))
 }
 
-fn module_tree(db: &impl ModulesDatabase) -> Arc<ModuleTreeDescriptor> {
+fn module_tree(db: &impl ModulesDatabase) -> Cancelable<Arc<ModuleTreeDescriptor>> {
+    db::check_canceled(db)?;
     let file_set = db.file_set();
     let mut files = Vec::new();
     for &file_id in file_set.files.iter() {
-        let module_descr = db.module_descriptor(file_id);
+        let module_descr = db.module_descriptor(file_id)?;
         files.push((file_id, module_descr));
     }
     let res = ModuleTreeDescriptor::new(
         files.iter().map(|(file_id, descr)| (*file_id, &**descr)),
         &file_set.resolver,
     );
-    Arc::new(res)
+    Ok(Arc::new(res))
 }
diff --git a/crates/ra_analysis/src/roots.rs b/crates/ra_analysis/src/roots.rs
index 19c84df65..123c4acfa 100644
--- a/crates/ra_analysis/src/roots.rs
+++ b/crates/ra_analysis/src/roots.rs
@@ -8,6 +8,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use salsa::Database;
 
 use crate::{
+    Cancelable,
     db::{self, FilesDatabase, SyntaxDatabase},
     descriptors::{ModuleDescriptor, ModuleTreeDescriptor},
     imp::FileResolverImp,
@@ -18,10 +19,10 @@ use crate::{
 
 pub(crate) trait SourceRoot {
     fn contains(&self, file_id: FileId) -> bool;
-    fn module_tree(&self) -> Arc<ModuleTreeDescriptor>;
+    fn module_tree(&self) -> Cancelable<Arc<ModuleTreeDescriptor>>;
     fn lines(&self, file_id: FileId) -> Arc<LineIndex>;
     fn syntax(&self, file_id: FileId) -> File;
-    fn symbols(&self, acc: &mut Vec<Arc<SymbolIndex>>);
+    fn symbols(&self, acc: &mut Vec<Arc<SymbolIndex>>) -> Cancelable<()>;
 }
 
 #[derive(Default, Debug, Clone)]
@@ -64,7 +65,7 @@ impl WritableSourceRoot {
 }
 
 impl SourceRoot for WritableSourceRoot {
-    fn module_tree(&self) -> Arc<ModuleTreeDescriptor> {
+    fn module_tree(&self) -> Cancelable<Arc<ModuleTreeDescriptor>> {
         self.db.module_tree()
     }
     fn contains(&self, file_id: FileId) -> bool {
@@ -76,14 +77,12 @@ impl SourceRoot for WritableSourceRoot {
     fn syntax(&self, file_id: FileId) -> File {
         self.db.file_syntax(file_id)
     }
-    fn symbols<'a>(&'a self, acc: &mut Vec<Arc<SymbolIndex>>) {
-        let db = &self.db;
-        let symbols = db.file_set();
-        let symbols = symbols
-            .files
-            .iter()
-            .map(|&file_id| db.file_symbols(file_id));
-        acc.extend(symbols);
+    fn symbols<'a>(&'a self, acc: &mut Vec<Arc<SymbolIndex>>) -> Cancelable<()> {
+        for &file_id in self.db.file_set().files.iter() {
+            let symbols = self.db.file_symbols(file_id)?;
+            acc.push(symbols)
+        }
+        Ok(())
     }
 }
 
@@ -167,8 +166,8 @@ impl ReadonlySourceRoot {
 }
 
 impl SourceRoot for ReadonlySourceRoot {
-    fn module_tree(&self) -> Arc<ModuleTreeDescriptor> {
-        Arc::clone(&self.module_tree)
+    fn module_tree(&self) -> Cancelable<Arc<ModuleTreeDescriptor>> {
+        Ok(Arc::clone(&self.module_tree))
     }
     fn contains(&self, file_id: FileId) -> bool {
         self.file_map.contains_key(&file_id)
@@ -179,7 +178,8 @@ impl SourceRoot for ReadonlySourceRoot {
     fn syntax(&self, file_id: FileId) -> File {
         self.data(file_id).syntax().clone()
     }
-    fn symbols(&self, acc: &mut Vec<Arc<SymbolIndex>>) {
-        acc.push(Arc::clone(&self.symbol_index))
+    fn symbols(&self, acc: &mut Vec<Arc<SymbolIndex>>) -> Cancelable<()> {
+        acc.push(Arc::clone(&self.symbol_index));
+        Ok(())
     }
 }
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index 51eef8170..a0f3c0437 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -1,4 +1,8 @@
-use crate::{FileId, JobToken, Query};
+use std::{
+    hash::{Hash, Hasher},
+    sync::Arc,
+};
+
 use fst::{self, Streamer};
 use ra_editor::{file_symbols, FileSymbol};
 use ra_syntax::{
@@ -7,10 +11,7 @@ use ra_syntax::{
 };
 use rayon::prelude::*;
 
-use std::{
-    hash::{Hash, Hasher},
-    sync::Arc,
-};
+use crate::{FileId, Query};
 
 #[derive(Debug)]
 pub(crate) struct SymbolIndex {
@@ -59,7 +60,6 @@ impl Query {
     pub(crate) fn search(
         self,
         indices: &[Arc<SymbolIndex>],
-        token: &JobToken,
     ) -> Vec<(FileId, FileSymbol)> {
         let mut op = fst::map::OpBuilder::new();
         for file_symbols in indices.iter() {
@@ -69,7 +69,7 @@ impl Query {
         let mut stream = op.union();
         let mut res = Vec::new();
         while let Some((_, indexed_values)) = stream.next() {
-            if res.len() >= self.limit || token.is_canceled() {
+            if res.len() >= self.limit {
                 break;
             }
             for indexed_value in indexed_values {