New VFS

crates/rust-analyzer/src/cli/diagnostics.rs

@@ -2,68 +2,57 @@
 //! code if any errors are found.
 
 use anyhow::anyhow;
+use hir::Crate;
 use ra_db::SourceDatabaseExt;
 use ra_ide::Severity;
 use std::{collections::HashSet, path::Path};
 
 use crate::cli::{load_cargo::load_cargo, Result};
-use hir::Semantics;
 
 pub fn diagnostics(
     path: &Path,
     load_output_dirs: bool,
     with_proc_macro: bool,
-    all: bool,
+    _all: bool,
 ) -> Result<()> {
-    let (host, roots) = load_cargo(path, load_output_dirs, with_proc_macro)?;
+    let (host, _vfs) = load_cargo(path, load_output_dirs, with_proc_macro)?;
     let db = host.raw_database();
     let analysis = host.analysis();
-    let semantics = Semantics::new(db);
-    let members = roots
-        .into_iter()
-        .filter_map(|(source_root_id, project_root)| {
-            // filter out dependencies
-            if project_root.is_member() {
-                Some(source_root_id)
-            } else {
-                None
-            }
-        })
-        .collect::<HashSet<_>>();
 
     let mut found_error = false;
     let mut visited_files = HashSet::new();
-    for source_root_id in members {
-        for file_id in db.source_root(source_root_id).walk() {
-            // Filter out files which are not actually modules (unless `--all` flag is
-            // passed). In the rust-analyzer repository this filters out the parser test files.
-            if semantics.to_module_def(file_id).is_some() || all {
-                if !visited_files.contains(&file_id) {
-                    let crate_name = if let Some(module) = semantics.to_module_def(file_id) {
-                        if let Some(name) = module.krate().display_name(db) {
-                            format!("{}", name)
-                        } else {
-                            String::from("unknown")
-                        }
-                    } else {
-                        String::from("unknown")
-                    };
-                    println!(
-                        "processing crate: {}, module: {}",
-                        crate_name,
-                        db.file_relative_path(file_id)
-                    );
-                    for diagnostic in analysis.diagnostics(file_id).unwrap() {
-                        if matches!(diagnostic.severity, Severity::Error) {
-                            found_error = true;
-                        }
 
-                        println!("{:?}", diagnostic);
-                    }
+    let mut work = Vec::new();
+    let krates = Crate::all(db);
+    for krate in krates {
+        let module = krate.root_module(db).expect("crate without root module");
+        let file_id = module.definition_source(db).file_id;
+        let file_id = file_id.original_file(db);
+        let source_root = db.file_source_root(file_id);
+        let source_root = db.source_root(source_root);
+        if !source_root.is_library {
+            work.push(module);
+        }
+    }
 
-                    visited_files.insert(file_id);
+    for module in work {
+        let file_id = module.definition_source(db).file_id.original_file(db);
+        if !visited_files.contains(&file_id) {
+            let crate_name = if let Some(name) = module.krate().display_name(db) {
+                format!("{}", name)
+            } else {
+                String::from("unknown")
+            };
+            println!("processing crate: {}, module: {}", crate_name, _vfs.file_path(file_id));
+            for diagnostic in analysis.diagnostics(file_id).unwrap() {
+                if matches!(diagnostic.severity, Severity::Error) {
+                    found_error = true;
                 }
+
+                println!("{:?}", diagnostic);
             }
+
+            visited_files.insert(file_id);
         }
     }