Merge branch 'workspaces'

Author: davidhalter

crates/cli_args/src/lib.rs

@@ -10,7 +10,7 @@ use vfs::{AbsPath, SimpleLocalFS, VfsHandler};
 
 use clap::Parser;
 
-#[derive(Parser, Default)]
+#[derive(Parser, Default, Debug)]
 pub struct Cli {
     // Additional options that are not present in zmypy
     /// Choosing a mode sets the basic preset of flags. The default mode is typed, which is not
@@ -46,7 +46,7 @@ impl Cli {
     }
 }
 
-#[derive(Parser, Clone, Default)]
+#[derive(Parser, Clone, Default, Debug)]
 pub struct MypyCli {
     // Running code:
     /// Regular expression to match file names, directory names or paths which mypy should ignore
@@ -297,6 +297,7 @@ pub fn apply_flags(
     cli: Cli,
     current_dir: Arc<AbsPath>,
     config_path: Option<&AbsPath>,
+    most_probable_base: Arc<AbsPath>,
 ) {
     apply_flags_detailed(
         vfs_handler,
@@ -306,6 +307,7 @@ pub fn apply_flags(
         cli,
         current_dir,
         config_path,
+        most_probable_base,
     )
 }
 
@@ -317,6 +319,7 @@ pub fn apply_flags_detailed(
     cli: Cli,
     current_dir: Arc<AbsPath>,
     config_path: Option<&AbsPath>,
+    most_probable_base: Arc<AbsPath>,
 ) {
     if let Some(mode) = cli.mode {
         settings.mode = mode.into();
@@ -333,7 +336,11 @@ pub fn apply_flags_detailed(
         cli.mypy_options,
         current_dir,
         config_path,
-    )
+    );
+
+    settings
+        .mypy_path
+        .push(vfs_handler.normalize_rc_path(most_probable_base));
 }
 
 fn apply_mypy_flags(
@@ -456,8 +463,4 @@ fn apply_mypy_flags(
             .map(|e| &e.regex_str)
             .collect::<Vec<_>>()
     );
-
-    settings
-        .mypy_path
-        .push(vfs_handler.normalize_rc_path(current_dir));
 }

crates/config/src/searcher.rs

@@ -22,39 +22,62 @@ pub struct FoundConfig {
     pub project_options: ProjectOptions,
     pub diagnostic_config: DiagnosticConfig,
     pub config_path: Option<Arc<AbsPath>>,
+    pub most_probable_base: Arc<AbsPath>,
 }
 
 pub fn find_workspace_config(
     vfs: &dyn VfsHandler,
-    workspace_dir: &AbsPath,
+    workspace_dir: Arc<AbsPath>,
     on_check_path: impl FnMut(&AbsPath),
 ) -> anyhow::Result<ProjectOptions> {
-    Ok(find_mypy_config_file_in_dir(vfs, workspace_dir, None, on_check_path)?.project_options)
+    let config = find_mypy_config_file_in_dir(vfs, workspace_dir, None, on_check_path)?;
+
+    Ok(match config {
+        Some(config) => config.project_options,
+        None => {
+            tracing::info!("No relevant config found");
+            ProjectOptions::default_for_mode(Mode::Default)
+        }
+    })
 }
 
 pub fn find_cli_config(
     vfs: &dyn VfsHandler,
-    current_dir: &AbsPath,
+    current_dir: Arc<AbsPath>,
     config_file: Option<&Path>,
     mode: Option<Mode>,
 ) -> anyhow::Result<FoundConfig> {
     if let Some(config_file) = config_file.as_ref() {
         let Some(config_path) = config_file.as_os_str().to_str() else {
             anyhow::bail!("Expected a valid UTF-8 encoded config path")
         };
-        let config_path = vfs.absolute_path(current_dir, config_path);
+        let config_path = vfs.absolute_path(&current_dir, config_path);
         let s = std::fs::read_to_string(config_path.as_ref())
             .map_err(|err| anyhow::anyhow!("Issue while reading {config_path}: {err}"))?;
 
-        let result = initialize_config(vfs, current_dir, config_path, s, mode)?;
+        let most_probable_base = Arc::from(vfs.parent_of_absolute_path(&config_path).unwrap());
+        let result = initialize_config(vfs, &current_dir, config_path, s, mode)?;
         let project_options = result.0.unwrap_or_else(ProjectOptions::mypy_default);
         Ok(FoundConfig {
             project_options,
             diagnostic_config: result.1,
             config_path: Some(result.2),
+            most_probable_base,
         })
     } else {
-        find_mypy_config_file_in_dir(vfs, current_dir, mode, |_| ())
+        let mut current = current_dir.clone();
+        loop {
+            if let Some(found) = find_mypy_config_file_in_dir(vfs, current.clone(), mode, |_| ())? {
+                return Ok(found);
+            }
+            if let Some(outer) = vfs.parent_of_absolute_path(&current) {
+                current = Arc::from(outer);
+            } else {
+                break;
+            }
+        }
+        tracing::info!("No relevant config found");
+        Ok(default_config(mode, None, current_dir))
     }
 }
 
@@ -90,28 +113,28 @@ fn initialize_config(
 
 fn find_mypy_config_file_in_dir(
     vfs: &dyn VfsHandler,
-    dir: &AbsPath,
+    dir: Arc<AbsPath>,
     mode: Option<Mode>,
     mut on_check_path: impl FnMut(&AbsPath),
-) -> anyhow::Result<FoundConfig> {
+) -> anyhow::Result<Option<FoundConfig>> {
     let mut end_result = None;
     let mut pyproject_toml: Option<DocumentMut> = None;
     for config_name in CONFIG_PATHS.iter() {
-        let path = vfs.join(dir, config_name);
+        let path = vfs.join(&dir, config_name);
         on_check_path(&path);
         if let Ok(mut file) = std::fs::File::open(path.as_ref()) {
             let mut content = String::new();
             if let Err(err) = file.read_to_string(&mut content) {
                 anyhow::bail!("Issue while reading {path}: {err}");
             }
-            let config_path = vfs.absolute_path(dir, config_name);
+            let config_path = vfs.absolute_path(&dir, config_name);
             tracing::info!("Potential config found: {config_path}");
             if *config_name == PYPROJECT_TOML_NAME {
                 let mut diagnostic_config = DiagnosticConfig::default();
                 pyproject_toml = Some(content.parse()?);
                 let project_options = ProjectOptions::apply_pyproject_toml_mypy_part(
                     vfs,
-                    dir,
+                    &dir,
                     &config_path,
                     pyproject_toml.as_ref().unwrap(),
                     &mut diagnostic_config,
@@ -122,11 +145,12 @@ fn find_mypy_config_file_in_dir(
                         project_options,
                         diagnostic_config,
                         config_path: Some(config_path),
+                        most_probable_base: dir.clone(),
                     });
                     break;
                 }
             } else {
-                let result = initialize_config(vfs, dir, config_path, content, mode)?;
+                let result = initialize_config(vfs, &dir, config_path, content, mode)?;
                 if let Some(project_options) = result.0.or_else(|| {
                     ["mypy.ini", ".mypy.ini"].contains(config_name).then(|| {
                         // Both mypy.ini and .mypy.ini always take precedent, even if there is no [mypy]
@@ -138,39 +162,47 @@ fn find_mypy_config_file_in_dir(
                         project_options,
                         diagnostic_config: result.1,
                         config_path: Some(result.2),
+                        most_probable_base: dir.clone(),
                     });
                     break;
                 }
             };
         }
     }
-    let default_config = |config_path| FoundConfig {
-        project_options: ProjectOptions::default_for_mode(mode.unwrap_or(Mode::Default)),
-        diagnostic_config: DiagnosticConfig::default(),
-        config_path,
-    };
     if let Some(pyproject_toml) = pyproject_toml
         && let Some(config) = pyproject_toml
             .get("tool")
             .and_then(|item| item.get("zuban"))
     {
         if end_result.is_none() {
-            end_result = Some(default_config(Some(
-                vfs.absolute_path(dir, PYPROJECT_TOML_NAME),
-            )));
+            end_result = Some(default_config(
+                mode,
+                Some(vfs.absolute_path(&dir, PYPROJECT_TOML_NAME)),
+                dir.clone(),
+            ));
         }
         let found = end_result.as_mut().unwrap();
         found.project_options.apply_pyproject_table(
             vfs,
-            dir,
+            &dir,
             found.config_path.as_ref().unwrap(),
             &mut found.diagnostic_config,
             config,
             true,
         )?
     }
-    Ok(end_result.unwrap_or_else(|| {
-        tracing::info!("No relevant config found");
-        default_config(None)
-    }))
+    Ok(end_result)
+}
+
+fn default_config(
+    mode: Option<Mode>,
+    config_path: Option<Arc<AbsPath>>,
+    current_dir: Arc<AbsPath>,
+) -> FoundConfig {
+    FoundConfig {
+        project_options: ProjectOptions::default_for_mode(mode.unwrap_or(Mode::Default)),
+        diagnostic_config: DiagnosticConfig::default(),
+        config_path,
+        most_probable_base: current_dir,
+    }
 }

crates/primer/src/main.rs

@@ -82,12 +82,12 @@ fn main() -> ExitCode {
         let cli = cli_args::Cli::parse_from(v);
         let result = zmypy::with_diagnostics_from_cli(
             cli,
-            pth,
+            &pth,
             Some(test_utils::typeshed_path()),
             |mut diagnostics, config| {
                 diagnostics.sort_issues_by_kind();
                 for diagnostic in diagnostics.issues.iter() {
-                    println!("{}", diagnostic.as_string(config))
+                    println!("{}", diagnostic.as_string(config, None))
                 }
                 file_count += diagnostics.checked_files;
                 issue_count += diagnostics.issues.len();