rename world -> analysis impl

crates/libanalysis/src/api.rs

@@ -1,7 +1,7 @@
 use relative_path::RelativePathBuf;
 use libsyntax2::{File, TextRange, TextUnit, AtomEdit};
 use libeditor;
-use {World, FileId, Query};
+use {imp::AnalysisImpl, FileId, Query};
 
 pub use libeditor::{
     LocalEdit, StructureNode, LineIndex, FileSymbol,
@@ -49,7 +49,7 @@ pub struct Diagnostic {
 
 #[derive(Clone, Debug)]
 pub struct Analysis {
-    pub(crate) imp: World
+    pub(crate) imp: AnalysisImpl
 }
 
 impl Analysis {

crates/libanalysis/src/imp.rs

@@ -0,0 +1,291 @@
+use std::{
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering::SeqCst},
+    },
+    fmt,
+    time::Instant,
+    collections::HashMap,
+    panic,
+};
+
+use libsyntax2::{
+    TextUnit, TextRange, SmolStr, File, AstNode,
+    SyntaxKind::*,
+    ast::{self, NameOwner},
+};
+use rayon::prelude::*;
+use once_cell::sync::OnceCell;
+use libeditor::{self, FileSymbol, LineIndex, find_node_at_offset};
+
+use {
+    FileId, FileResolver, Query, Diagnostic, SourceChange, FileSystemEdit,
+    module_map::Problem,
+    symbol_index::FileSymbols,
+    module_map::ModuleMap,
+};
+
+
+pub(crate) struct AnalysisImpl {
+    pub(crate) needs_reindex: AtomicBool,
+    pub(crate) file_resolver: Arc<FileResolver>,
+    pub(crate) data: Arc<WorldData>,
+}
+
+impl fmt::Debug for AnalysisImpl {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        (&*self.data).fmt(f)
+    }
+}
+
+impl Clone for AnalysisImpl {
+    fn clone(&self) -> AnalysisImpl {
+        AnalysisImpl {
+            needs_reindex: AtomicBool::new(self.needs_reindex.load(SeqCst)),
+            file_resolver: Arc::clone(&self.file_resolver),
+            data: Arc::clone(&self.data),
+        }
+    }
+}
+
+impl AnalysisImpl {
+    pub fn file_syntax(&self, file_id: FileId) -> File {
+        self.file_data(file_id).syntax().clone()
+    }
+
+    pub fn file_line_index(&self, id: FileId) -> LineIndex {
+        let data = self.file_data(id);
+        data
+            .lines
+            .get_or_init(|| LineIndex::new(&data.text))
+            .clone()
+    }
+
+    pub fn world_symbols(&self, mut query: Query) -> Vec<(FileId, FileSymbol)> {
+        self.reindex();
+        self.data.file_map.iter()
+            .flat_map(move |(id, data)| {
+                let symbols = data.symbols();
+                query.process(symbols).into_iter().map(move |s| (*id, s))
+            })
+            .collect()
+    }
+
+    pub fn parent_module(&self, id: FileId) -> Vec<(FileId, FileSymbol)> {
+        let module_map = &self.data.module_map;
+        let id = module_map.file2module(id);
+        module_map
+            .parent_modules(
+                id,
+                &*self.file_resolver,
+                &|file_id| self.file_syntax(file_id),
+            )
+            .into_iter()
+            .map(|(id, name, node)| {
+                let id = module_map.module2file(id);
+                let sym = FileSymbol {
+                    name,
+                    node_range: node.range(),
+                    kind: MODULE,
+                };
+                (id, sym)
+            })
+            .collect()
+    }
+
+    pub fn approximately_resolve_symbol(
+        &self,
+        id: FileId,
+        offset: TextUnit,
+    ) -> Vec<(FileId, FileSymbol)> {
+        let file = self.file_syntax(id);
+        let syntax = file.syntax();
+        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, offset) {
+            return 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) {
+                if module.has_semi() {
+                    let file_ids = self.resolve_module(id, module);
+
+                    let res = file_ids.into_iter().map(|id| {
+                        let name = module.name()
+                            .map(|n| n.text())
+                            .unwrap_or_else(|| SmolStr::new(""));
+                        let symbol = FileSymbol {
+                            name,
+                            node_range: TextRange::offset_len(0.into(), 0.into()),
+                            kind: MODULE,
+                        };
+                        (id, symbol)
+                    }).collect();
+
+                    return res;
+                }
+            }
+        }
+        vec![]
+    }
+
+    pub fn diagnostics(&self, file_id: FileId) -> Vec<Diagnostic> {
+        let syntax = self.file_syntax(file_id);
+        let mut res = libeditor::diagnostics(&syntax)
+            .into_iter()
+            .map(|d| Diagnostic { range: d.range, message: d.msg, fix: None })
+            .collect::<Vec<_>>();
+
+        self.data.module_map.problems(
+            file_id,
+            &*self.file_resolver,
+            &|file_id| self.file_syntax(file_id),
+            |name_node, problem| {
+                let diag = match problem {
+                    Problem::UnresolvedModule { candidate } => {
+                        let create_file = FileSystemEdit::CreateFile {
+                            anchor: file_id,
+                            path: candidate.clone(),
+                        };
+                        let fix = SourceChange {
+                            label: "create module".to_string(),
+                            source_file_edits: Vec::new(),
+                            file_system_edits: vec![create_file],
+                            cursor_position: None,
+                        };
+                        Diagnostic {
+                            range: name_node.syntax().range(),
+                            message: "unresolved module".to_string(),
+                            fix: Some(fix),
+                        }
+                    }
+                    Problem::NotDirOwner { move_to, candidate } => {
+                        let move_file = FileSystemEdit::MoveFile { file: file_id, path: move_to.clone() };
+                        let create_file = FileSystemEdit::CreateFile { anchor: file_id, path: move_to.join(candidate) };
+                        let fix = SourceChange {
+                            label: "move file and create module".to_string(),
+                            source_file_edits: Vec::new(),
+                            file_system_edits: vec![move_file, create_file],
+                            cursor_position: None,
+                        };
+                        Diagnostic {
+                            range: name_node.syntax().range(),
+                            message: "can't declare module at this location".to_string(),
+                            fix: Some(fix),
+                        }
+                    }
+                };
+                res.push(diag)
+            }
+        );
+        res
+    }
+
+    pub fn assists(&self, file_id: FileId, offset: TextUnit) -> Vec<SourceChange> {
+        let file = self.file_syntax(file_id);
+        let actions = vec![
+            ("flip comma", libeditor::flip_comma(&file, offset).map(|f| f())),
+            ("add `#[derive]`", libeditor::add_derive(&file, offset).map(|f| f())),
+            ("add impl", libeditor::add_impl(&file, offset).map(|f| f())),
+        ];
+        let mut res = Vec::new();
+        for (name, local_edit) in actions {
+            if let Some(local_edit) = local_edit {
+                res.push(SourceChange::from_local_edit(
+                    file_id, name, local_edit
+                ))
+            }
+        }
+        res
+    }
+
+    fn index_resolve(&self, name_ref: ast::NameRef) -> 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)
+    }
+
+    fn resolve_module(&self, id: FileId, module: ast::Module) -> Vec<FileId> {
+        let name = match module.name() {
+            Some(name) => name.text(),
+            None => return Vec::new(),
+        };
+        let module_map = &self.data.module_map;
+        let id = module_map.file2module(id);
+        module_map
+            .child_module_by_name(
+                id, name.as_str(),
+                &*self.file_resolver,
+                &|file_id| self.file_syntax(file_id),
+            )
+            .into_iter()
+            .map(|id| module_map.module2file(id))
+            .collect()
+    }
+
+    fn reindex(&self) {
+        if self.needs_reindex.compare_and_swap(false, true, SeqCst) {
+            let now = Instant::now();
+            let data = &*self.data;
+            data.file_map
+                .par_iter()
+                .for_each(|(_, data)| drop(data.symbols()));
+            info!("parallel indexing took {:?}", now.elapsed());
+        }
+    }
+
+    fn file_data(&self, file_id: FileId) -> Arc<FileData> {
+        match self.data.file_map.get(&file_id) {
+            Some(data) => data.clone(),
+            None => panic!("unknown file: {:?}", file_id),
+        }
+    }
+}
+
+#[derive(Default, Debug)]
+pub(crate) struct WorldData {
+    pub(crate) file_map: HashMap<FileId, Arc<FileData>>,
+    pub(crate) module_map: ModuleMap,
+}
+
+#[derive(Debug)]
+pub(crate) struct FileData {
+    pub(crate) text: String,
+    pub(crate) symbols: OnceCell<FileSymbols>,
+    pub(crate) syntax: OnceCell<File>,
+    pub(crate) lines: OnceCell<LineIndex>,
+}
+
+impl FileData {
+    pub(crate) fn new(text: String) -> FileData {
+        FileData {
+            text,
+            symbols: OnceCell::new(),
+            syntax: OnceCell::new(),
+            lines: OnceCell::new(),
+        }
+    }
+
+    fn syntax(&self) -> &File {
+        let text = &self.text;
+        let syntax = &self.syntax;
+        match panic::catch_unwind(panic::AssertUnwindSafe(|| syntax.get_or_init(|| File::parse(text)))) {
+            Ok(file) => file,
+            Err(err) => {
+                error!("Parser paniced on:\n------\n{}\n------\n", &self.text);
+                panic::resume_unwind(err)
+            }
+        }
+    }
+
+    fn syntax_transient(&self) -> File {
+        self.syntax.get().map(|s| s.clone())
+            .unwrap_or_else(|| File::parse(&self.text))
+    }
+
+    fn symbols(&self) -> &FileSymbols {
+        let syntax = self.syntax_transient();
+        self.symbols
+            .get_or_init(|| FileSymbols::new(&syntax))
+    }
+}

crates/libanalysis/src/lib.rs

@@ -1,4 +1,3 @@
-#[macro_use]
 extern crate failure;
 extern crate parking_lot;
 #[macro_use]
@@ -13,33 +12,20 @@ extern crate relative_path;
 mod symbol_index;
 mod module_map;
 mod api;
+mod imp;
 
 use std::{
-    fmt,
-    panic,
     sync::{
         Arc,
-        atomic::{AtomicBool, Ordering::SeqCst},
+        atomic::{AtomicBool},
     },
-    collections::hash_map::HashMap,
-    time::Instant,
 };
 
 use relative_path::RelativePath;
-use once_cell::sync::OnceCell;
-use rayon::prelude::*;
-
-use libsyntax2::{
-    File,
-    TextUnit, TextRange, SmolStr,
-    ast::{self, AstNode, NameOwner},
-    SyntaxKind::*,
-};
-use libeditor::{LineIndex, FileSymbol, find_node_at_offset};
 
 use self::{
-    symbol_index::FileSymbols,
+    module_map::{ChangeKind},
-    module_map::{ModuleMap, ChangeKind, Problem},
+    imp::{WorldData, FileData},
 };
 pub use self::symbol_index::Query;
 pub use self::api::{
@@ -58,28 +44,6 @@ pub struct WorldState {
     data: Arc<WorldData>
 }
 
-pub(crate) struct World {
-    needs_reindex: AtomicBool,
-    file_resolver: Arc<FileResolver>,
-    data: Arc<WorldData>,
-}
-
-impl fmt::Debug for World {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        (&*self.data).fmt(f)
-    }
-}
-
-impl Clone for World {
-    fn clone(&self) -> World {
-        World {
-            needs_reindex: AtomicBool::new(self.needs_reindex.load(SeqCst)),
-            file_resolver: Arc::clone(&self.file_resolver),
-            data: Arc::clone(&self.data),
-        }
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct FileId(pub u32);
 
@@ -94,7 +58,7 @@ impl WorldState {
         &self,
         file_resolver: impl FileResolver,
     ) -> Analysis {
-        let imp = World {
+        let imp = imp::AnalysisImpl {
             needs_reindex: AtomicBool::new(false),
             file_resolver: Arc::new(file_resolver),
             data: self.data.clone()
@@ -139,245 +103,3 @@ impl WorldState {
         Arc::get_mut(&mut self.data).unwrap()
     }
 }
-
-impl World {
-    pub fn file_syntax(&self, file_id: FileId) -> File {
-        self.file_data(file_id).syntax().clone()
-    }
-
-    pub fn file_line_index(&self, id: FileId) -> LineIndex {
-        let data = self.file_data(id);
-        data
-            .lines
-            .get_or_init(|| LineIndex::new(&data.text))
-            .clone()
-    }
-
-    pub fn world_symbols(&self, mut query: Query) -> Vec<(FileId, FileSymbol)> {
-        self.reindex();
-        self.data.file_map.iter()
-            .flat_map(move |(id, data)| {
-                let symbols = data.symbols();
-                query.process(symbols).into_iter().map(move |s| (*id, s))
-            })
-            .collect()
-    }
-
-    pub fn parent_module(&self, id: FileId) -> Vec<(FileId, FileSymbol)> {
-        let module_map = &self.data.module_map;
-        let id = module_map.file2module(id);
-        module_map
-            .parent_modules(
-                id,
-                &*self.file_resolver,
-                &|file_id| self.file_syntax(file_id),
-            )
-            .into_iter()
-            .map(|(id, name, node)| {
-                let id = module_map.module2file(id);
-                let sym = FileSymbol {
-                    name,
-                    node_range: node.range(),
-                    kind: MODULE,
-                };
-                (id, sym)
-            })
-            .collect()
-    }
-
-    pub fn approximately_resolve_symbol(
-        &self,
-        id: FileId,
-        offset: TextUnit,
-    ) -> Vec<(FileId, FileSymbol)> {
-        let file = self.file_syntax(id);
-        let syntax = file.syntax();
-        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, offset) {
-            return 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) {
-                if module.has_semi() {
-                    let file_ids = self.resolve_module(id, module);
-
-                    let res = file_ids.into_iter().map(|id| {
-                        let name = module.name()
-                            .map(|n| n.text())
-                            .unwrap_or_else(|| SmolStr::new(""));
-                        let symbol = FileSymbol {
-                            name,
-                            node_range: TextRange::offset_len(0.into(), 0.into()),
-                            kind: MODULE,
-                        };
-                        (id, symbol)
-                    }).collect();
-
-                    return res;
-                }
-            }
-        }
-        vec![]
-    }
-
-    pub fn diagnostics(&self, file_id: FileId) -> Vec<Diagnostic> {
-        let syntax = self.file_syntax(file_id);
-        let mut res = libeditor::diagnostics(&syntax)
-            .into_iter()
-            .map(|d| Diagnostic { range: d.range, message: d.msg, fix: None })
-            .collect::<Vec<_>>();
-
-        self.data.module_map.problems(
-            file_id,
-            &*self.file_resolver,
-            &|file_id| self.file_syntax(file_id),
-            |name_node, problem| {
-                let diag = match problem {
-                    Problem::UnresolvedModule { candidate } => {
-                        let create_file = FileSystemEdit::CreateFile {
-                            anchor: file_id,
-                            path: candidate.clone(),
-                        };
-                        let fix = SourceChange {
-                            label: "create module".to_string(),
-                            source_file_edits: Vec::new(),
-                            file_system_edits: vec![create_file],
-                            cursor_position: None,
-                        };
-                        Diagnostic {
-                            range: name_node.syntax().range(),
-                            message: "unresolved module".to_string(),
-                            fix: Some(fix),
-                        }
-                    }
-                    Problem::NotDirOwner { move_to, candidate } => {
-                        let move_file = FileSystemEdit::MoveFile { file: file_id, path: move_to.clone() };
-                        let create_file = FileSystemEdit::CreateFile { anchor: file_id, path: move_to.join(candidate) };
-                        let fix = SourceChange {
-                            label: "move file and create module".to_string(),
-                            source_file_edits: Vec::new(),
-                            file_system_edits: vec![move_file, create_file],
-                            cursor_position: None,
-                        };
-                        Diagnostic {
-                            range: name_node.syntax().range(),
-                            message: "can't declare module at this location".to_string(),
-                            fix: Some(fix),
-                        }
-                    }
-                };
-                res.push(diag)
-            }
-        );
-        res
-    }
-
-    pub fn assists(&self, file_id: FileId, offset: TextUnit) -> Vec<SourceChange> {
-        let file = self.file_syntax(file_id);
-        let actions = vec![
-            ("flip comma", libeditor::flip_comma(&file, offset).map(|f| f())),
-            ("add `#[derive]`", libeditor::add_derive(&file, offset).map(|f| f())),
-            ("add impl", libeditor::add_impl(&file, offset).map(|f| f())),
-        ];
-        let mut res = Vec::new();
-        for (name, local_edit) in actions {
-            if let Some(local_edit) = local_edit {
-                res.push(SourceChange::from_local_edit(
-                    file_id, name, local_edit
-                ))
-            }
-        }
-        res
-    }
-
-    fn index_resolve(&self, name_ref: ast::NameRef) -> 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)
-    }
-
-    fn resolve_module(&self, id: FileId, module: ast::Module) -> Vec<FileId> {
-        let name = match module.name() {
-            Some(name) => name.text(),
-            None => return Vec::new(),
-        };
-        let module_map = &self.data.module_map;
-        let id = module_map.file2module(id);
-        module_map
-            .child_module_by_name(
-                id, name.as_str(),
-                &*self.file_resolver,
-                &|file_id| self.file_syntax(file_id),
-            )
-            .into_iter()
-            .map(|id| module_map.module2file(id))
-            .collect()
-    }
-
-    fn reindex(&self) {
-        if self.needs_reindex.compare_and_swap(false, true, SeqCst) {
-            let now = Instant::now();
-            let data = &*self.data;
-            data.file_map
-                .par_iter()
-                .for_each(|(_, data)| drop(data.symbols()));
-            info!("parallel indexing took {:?}", now.elapsed());
-        }
-    }
-
-    fn file_data(&self, file_id: FileId) -> Arc<FileData> {
-        match self.data.file_map.get(&file_id) {
-            Some(data) => data.clone(),
-            None => panic!("unknown file: {:?}", file_id),
-        }
-    }
-}
-
-#[derive(Default, Debug)]
-struct WorldData {
-    file_map: HashMap<FileId, Arc<FileData>>,
-    module_map: ModuleMap,
-}
-
-#[derive(Debug)]
-struct FileData {
-    text: String,
-    symbols: OnceCell<FileSymbols>,
-    syntax: OnceCell<File>,
-    lines: OnceCell<LineIndex>,
-}
-
-impl FileData {
-    fn new(text: String) -> FileData {
-        FileData {
-            text,
-            symbols: OnceCell::new(),
-            syntax: OnceCell::new(),
-            lines: OnceCell::new(),
-        }
-    }
-
-    fn syntax(&self) -> &File {
-        let text = &self.text;
-        let syntax = &self.syntax;
-        match panic::catch_unwind(panic::AssertUnwindSafe(|| syntax.get_or_init(|| File::parse(text)))) {
-            Ok(file) => file,
-            Err(err) => {
-                error!("Parser paniced on:\n------\n{}\n------\n", &self.text);
-                panic::resume_unwind(err)
-            }
-        }
-    }
-
-    fn syntax_transient(&self) -> File {
-        self.syntax.get().map(|s| s.clone())
-            .unwrap_or_else(|| File::parse(&self.text))
-    }
-
-    fn symbols(&self) -> &FileSymbols {
-        let syntax = self.syntax_transient();
-        self.symbols
-            .get_or_init(|| FileSymbols::new(&syntax))
-    }
-}