Happy path implemented

SomeoneToIgnore · SomeoneToIgnore · commit 8aa740dab46f · 2020-09-10T01:42:20.000+03:00
diff --git a/crates/base_db/src/lib.rs b/crates/base_db/src/lib.rs
@@ -96,7 +96,7 @@ pub trait FileLoader {
     /// `#[path = "C://no/way"]`
     fn resolve_path(&self, anchor: FileId, path: &str) -> Option<FileId>;
     fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>>;
-    fn possible_sudmobules(&self, module_file: FileId) -> Vec<(FileId, String)>;
+    fn possible_sudmobule_names(&self, module_file: FileId) -> Vec<String>;
 }
 
 /// Database which stores all significant input facts: source code and project
@@ -166,11 +166,11 @@ impl<T: SourceDatabaseExt> FileLoader for FileLoaderDelegate<&'_ T> {
         self.0.source_root_crates(source_root)
     }
 
-    fn possible_sudmobules(&self, module_file: FileId) -> Vec<(FileId, String)> {
+    fn possible_sudmobule_names(&self, module_file: FileId) -> Vec<String> {
         fn possible_sudmobules_opt(
             module_files: &FileSet,
             module_file: FileId,
-        ) -> Option<Vec<(FileId, String)>> {
+        ) -> Option<Vec<FileId>> {
             match module_files.file_name_and_extension(module_file)? {
                 ("mod", Some("rs")) | ("lib", Some("rs")) => {
                     module_files.list_files(module_file, None)
@@ -181,8 +181,16 @@ impl<T: SourceDatabaseExt> FileLoader for FileLoaderDelegate<&'_ T> {
             }
         }
 
-        possible_sudmobules_opt(&self.source_root(module_file).file_set, module_file)
+        let module_files = &self.source_root(module_file).file_set;
+        possible_sudmobules_opt(module_files, module_file)
             .unwrap_or_default()
+            .into_iter()
+            .filter_map(|submodule_file| module_files.file_name_and_extension(submodule_file))
+            .map(|(file_name, extension)| match extension {
+                Some(extension) => format!("{}.{}", file_name, extension),
+                None => file_name.to_owned(),
+            })
+            .collect()
     }
 }
 
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
@@ -63,8 +63,8 @@ impl FileLoader for TestDB {
     fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>> {
         FileLoaderDelegate(self).relevant_crates(file_id)
     }
-    fn possible_sudmobules(&self, module_file: FileId) -> Vec<(FileId, String)> {
-        FileLoaderDelegate(self).possible_sudmobules(module_file)
+    fn possible_sudmobule_names(&self, module_file: FileId) -> Vec<String> {
+        FileLoaderDelegate(self).possible_sudmobule_names(module_file)
     }
 }
 
diff --git a/crates/hir_expand/src/test_db.rs b/crates/hir_expand/src/test_db.rs
@@ -46,7 +46,7 @@ impl FileLoader for TestDB {
     fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>> {
         FileLoaderDelegate(self).relevant_crates(file_id)
     }
-    fn possible_sudmobules(&self, module_file: FileId) -> Vec<(FileId, String)> {
-        FileLoaderDelegate(self).possible_sudmobules(module_file)
+    fn possible_sudmobule_names(&self, module_file: FileId) -> Vec<String> {
+        FileLoaderDelegate(self).possible_sudmobule_names(module_file)
     }
 }
diff --git a/crates/hir_ty/src/test_db.rs b/crates/hir_ty/src/test_db.rs
@@ -73,8 +73,8 @@ impl FileLoader for TestDB {
     fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>> {
         FileLoaderDelegate(self).relevant_crates(file_id)
     }
-    fn possible_sudmobules(&self, module_file: FileId) -> Vec<(FileId, String)> {
-        FileLoaderDelegate(self).possible_sudmobules(module_file)
+    fn possible_sudmobule_names(&self, module_file: FileId) -> Vec<String> {
+        FileLoaderDelegate(self).possible_sudmobule_names(module_file)
     }
 }
 
diff --git a/crates/ide/src/completion/completion_context.rs b/crates/ide/src/completion/completion_context.rs
@@ -122,7 +122,7 @@ impl<'a> CompletionContext<'a> {
                     }
                     let module_definition_source_file = definition_source.file_id.original_file(db);
                     let mod_declaration_candidates =
-                        db.possible_sudmobules(module_definition_source_file);
+                        db.possible_sudmobule_names(module_definition_source_file);
                     dbg!(mod_declaration_candidates);
                     // TODO kb exlude existing children from the candidates
                     let existing_children = current_module.children(db).collect::<Vec<_>>();
diff --git a/crates/ide_db/src/lib.rs b/crates/ide_db/src/lib.rs
@@ -74,8 +74,8 @@ impl FileLoader for RootDatabase {
     fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>> {
         FileLoaderDelegate(self).relevant_crates(file_id)
     }
-    fn possible_sudmobules(&self, module_file: FileId) -> Vec<(FileId, String)> {
-        FileLoaderDelegate(self).possible_sudmobules(module_file)
+    fn possible_sudmobule_names(&self, module_file: FileId) -> Vec<String> {
+        FileLoaderDelegate(self).possible_sudmobule_names(module_file)
     }
 }
 
diff --git a/crates/vfs/src/file_set.rs b/crates/vfs/src/file_set.rs
@@ -34,22 +34,27 @@ impl FileSet {
         &self,
         anchor: FileId,
         anchor_relative_path: Option<&str>,
-    ) -> Option<Vec<(FileId, String)>> {
+    ) -> Option<Vec<FileId>> {
         let anchor_directory = {
             let path = self.paths[&anchor].clone();
             match anchor_relative_path {
                 Some(anchor_relative_path) => path.join(anchor_relative_path),
-                None => path.join("../"),
+                None => path.parent(),
             }
         }?;
 
         Some(
             self.paths
                 .iter()
-                .filter(|(_, path)| path.starts_with(&anchor_directory))
-                // TODO kb need to ensure that no / exists after the anchor_directory
-                .filter(|(_, path)| path.ends_with(".rs"))
-                .map(|(&file_id, path)| (file_id, path.to_string()))
+                .filter_map(|(&file_id, path)| {
+                    if path.parent()? == anchor_directory
+                        && matches!(path.file_name_and_extension(), Some((_, Some("rs"))))
+                    {
+                        Some(file_id)
+                    } else {
+                        None
+                    }
+                })
                 .collect(),
         )
     }
diff --git a/crates/vfs/src/vfs_path.rs b/crates/vfs/src/vfs_path.rs
@@ -48,10 +48,12 @@ impl VfsPath {
             (VfsPathRepr::VirtualPath(_), _) => false,
         }
     }
-    pub fn ends_with(&self, suffix: &str) -> bool {
-        match &self.0 {
-            VfsPathRepr::PathBuf(p) => p.ends_with(suffix),
-            VfsPathRepr::VirtualPath(p) => p.ends_with(suffix),
+    pub fn parent(&self) -> Option<VfsPath> {
+        let mut parent = self.clone();
+        if parent.pop() {
+            Some(parent)
+        } else {
+            None
         }
     }
 
@@ -265,9 +267,6 @@ impl VirtualPath {
     fn starts_with(&self, other: &VirtualPath) -> bool {
         self.0.starts_with(&other.0)
     }
-    fn ends_with(&self, suffix: &str) -> bool {
-        self.0.ends_with(suffix)
-    }
     fn pop(&mut self) -> bool {
         let pos = match self.0.rfind('/') {
             Some(pos) => pos,

Original file line number	Diff line number	Diff line change
`@@ -63,8 +63,8 @@ impl FileLoader for TestDB {`
`63`	`63`	`fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>> {`
`64`	`64`	`FileLoaderDelegate(self).relevant_crates(file_id)`
`65`	`65`	`}`
`66`		`- fn possible_sudmobules(&self, module_file: FileId) -> Vec<(FileId, String)> {`
`67`		`- FileLoaderDelegate(self).possible_sudmobules(module_file)`
	`66`	`+ fn possible_sudmobule_names(&self, module_file: FileId) -> Vec<String> {`
	`67`	`+ FileLoaderDelegate(self).possible_sudmobule_names(module_file)`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ impl FileLoader for TestDB {`
`46`	`46`	`fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>> {`
`47`	`47`	`FileLoaderDelegate(self).relevant_crates(file_id)`
`48`	`48`	`}`
`49`		`- fn possible_sudmobules(&self, module_file: FileId) -> Vec<(FileId, String)> {`
`50`		`- FileLoaderDelegate(self).possible_sudmobules(module_file)`
	`49`	`+ fn possible_sudmobule_names(&self, module_file: FileId) -> Vec<String> {`
	`50`	`+ FileLoaderDelegate(self).possible_sudmobule_names(module_file)`
`51`	`51`	`}`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,8 +73,8 @@ impl FileLoader for TestDB {`
`73`	`73`	`fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>> {`
`74`	`74`	`FileLoaderDelegate(self).relevant_crates(file_id)`
`75`	`75`	`}`
`76`		`- fn possible_sudmobules(&self, module_file: FileId) -> Vec<(FileId, String)> {`
`77`		`- FileLoaderDelegate(self).possible_sudmobules(module_file)`
	`76`	`+ fn possible_sudmobule_names(&self, module_file: FileId) -> Vec<String> {`
	`77`	`+ FileLoaderDelegate(self).possible_sudmobule_names(module_file)`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`
Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ impl<'a> CompletionContext<'a> {`
`122`	`122`	`}`
`123`	`123`	`let module_definition_source_file = definition_source.file_id.original_file(db);`
`124`	`124`	`let mod_declaration_candidates =`
`125`		`- db.possible_sudmobules(module_definition_source_file);`
	`125`	`+ db.possible_sudmobule_names(module_definition_source_file);`
`126`	`126`	`dbg!(mod_declaration_candidates);`
`127`	`127`	`// TODO kb exlude existing children from the candidates`
`128`	`128`	`let existing_children = current_module.children(db).collect::<Vec<_>>();`
Original file line number	Diff line number	Diff line change
`@@ -74,8 +74,8 @@ impl FileLoader for RootDatabase {`
`74`	`74`	`fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>> {`
`75`	`75`	`FileLoaderDelegate(self).relevant_crates(file_id)`
`76`	`76`	`}`
`77`		`- fn possible_sudmobules(&self, module_file: FileId) -> Vec<(FileId, String)> {`
`78`		`- FileLoaderDelegate(self).possible_sudmobules(module_file)`
	`77`	`+ fn possible_sudmobule_names(&self, module_file: FileId) -> Vec<String> {`
	`78`	`+ FileLoaderDelegate(self).possible_sudmobule_names(module_file)`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
Original file line number	Diff line number	Diff line change
`@@ -48,10 +48,12 @@ impl VfsPath {`
`48`	`48`	`(VfsPathRepr::VirtualPath(_), _) => false,`
`49`	`49`	`}`
`50`	`50`	`}`
`51`		`- pub fn ends_with(&self, suffix: &str) -> bool {`
`52`		`- match &self.0 {`
`53`		`- VfsPathRepr::PathBuf(p) => p.ends_with(suffix),`
`54`		`- VfsPathRepr::VirtualPath(p) => p.ends_with(suffix),`
	`51`	`+ pub fn parent(&self) -> Option<VfsPath> {`
	`52`	`+ let mut parent = self.clone();`
	`53`	`+ if parent.pop() {`
	`54`	`+ Some(parent)`
	`55`	`+ } else {`
	`56`	`+ None`
`55`	`57`	`}`
`56`	`58`	`}`
`57`	`59`
`@@ -265,9 +267,6 @@ impl VirtualPath {`
`265`	`267`	`fn starts_with(&self, other: &VirtualPath) -> bool {`
`266`	`268`	`self.0.starts_with(&other.0)`
`267`	`269`	`}`
`268`		`- fn ends_with(&self, suffix: &str) -> bool {`
`269`		`- self.0.ends_with(suffix)`
`270`		`- }`
`271`	`270`	`fn pop(&mut self) -> bool {`
`272`	`271`	`let pos = match self.0.rfind('/') {`
`273`	`272`	`Some(pos) => pos,`