Make missing-source respect error configuration

Summary:
Previously, the `missing-source` error ignored all error configuration (e.g., requesting `--error=missing-source` did nothing). Now this error respects configuration. Implementation-wise, this means we always log the error and choose whether to display it or not based on the configured severity level, rather than choosing whether to log it or not based on the value of `--ignore-missing-source`.

For backwards compatibility, I also preserved the behavior of `--ignore-missing-source=false` (enable `missing-source` with severity Error). This does lead to a bit of weirdness when `missing-source` is configured in multiple ways. What I ended up doing is enabling the error if it is explicitly enabled in any way (even if it is also explicitly disabled in a different way!), with the severity defaulting to Error if unspecified.

Maybe we should deprecated `--ignore-missing-source` at some point? (cc connernilsen) But I think the behavior in this diff is good enough for now.

For #1406.

Reviewed By: connernilsen

Differential Revision: D85622655

fbshipit-source-id: 45a67f52306303c84b07ba888a7c185e60b18411

Author: rchen152

crates/pyrefly_config/src/config.rs

@@ -676,6 +676,7 @@ impl ConfigFile {
             self.errors(path),
             self.ignore_errors_in_generated_code(path),
             self.permissive_ignores(path),
+            self.ignore_missing_source,
         )
     }
 

crates/pyrefly_config/src/error.rs

@@ -91,18 +91,21 @@ pub struct ErrorConfig<'a> {
     pub display_config: &'a ErrorDisplayConfig,
     pub ignore_errors_in_generated_code: bool,
     pub permissive_ignores: bool,
+    pub ignore_missing_source: bool,
 }
 
 impl<'a> ErrorConfig<'a> {
     pub fn new(
         display_config: &'a ErrorDisplayConfig,
         ignore_errors_in_generated_code: bool,
         permissive_ignores: bool,
+        ignore_missing_source: bool,
     ) -> Self {
         Self {
             display_config,
             ignore_errors_in_generated_code,
             permissive_ignores,
+            ignore_missing_source,
         }
     }
 }

crates/pyrefly_config/src/error_kind.rs

@@ -284,6 +284,7 @@ impl ErrorKind {
             ErrorKind::ImplicitlyDefinedAttribute => Severity::Ignore,
             ErrorKind::ImplicitAbstractClass => Severity::Ignore,
             ErrorKind::ImplicitAny => Severity::Ignore,
+            ErrorKind::MissingSource => Severity::Ignore,
             _ => Severity::Error,
         }
     }

pyrefly/lib/error/collector.rs

@@ -9,6 +9,7 @@ use std::fmt::Debug;
 use std::mem;
 
 use dupe::Dupe;
+use pyrefly_config::error_kind::ErrorKind;
 use pyrefly_util::lock::Mutex;
 use ruff_text_size::Ranged;
 use ruff_text_size::TextRange;
@@ -161,7 +162,18 @@ impl ErrorCollector {
                 if err.is_ignored(error_config.permissive_ignores) {
                     result.suppressed.push(err.clone());
                 } else {
-                    match error_config.display_config.severity(err.error_kind()) {
+                    let kind = err.error_kind();
+                    let raw_severity = error_config.display_config.severity(kind);
+                    let severity = match (kind, raw_severity, error_config.ignore_missing_source) {
+                        // If missing-source is set to Ignore (the default), and
+                        // ignore-missing-source is  to false (the default is true, so false must
+                        // have been explicitly set by the user), enable missing-source. Note that
+                        // this means that if `missing-source` and `--ignore-missing-source` are in
+                        // conflict,  the error is enabled if either setting says it should be.
+                        (ErrorKind::MissingSource, Severity::Ignore, false) => Severity::Error,
+                        _ => raw_severity,
+                    };
+                    match severity {
                         Severity::Error => result.shown.push(err.with_severity(Severity::Error)),
                         Severity::Warn => result.shown.push(err.with_severity(Severity::Warn)),
                         Severity::Info => result.shown.push(err.with_severity(Severity::Info)),
@@ -245,7 +257,8 @@ mod tests {
                 .collect(&ErrorConfig::new(
                     &ErrorDisplayConfig::default(),
                     false,
-                    false
+                    false,
+                    true,
                 ))
                 .shown
                 .map(|x| x.msg()),
@@ -297,7 +310,7 @@ mod tests {
             (ErrorKind::BadAssignment, Severity::Ignore),
             (ErrorKind::NotIterable, Severity::Ignore),
         ]));
-        let config = ErrorConfig::new(&display_config, false, false);
+        let config = ErrorConfig::new(&display_config, false, false, true);
 
         assert_eq!(
             errors.collect(&config).shown.map(|x| x.msg()),
@@ -321,10 +334,10 @@ mod tests {
         );
 
         let display_config = ErrorDisplayConfig::default();
-        let config0 = ErrorConfig::new(&display_config, false, false);
+        let config0 = ErrorConfig::new(&display_config, false, false, true);
         assert_eq!(errors.collect(&config0).shown.map(|x| x.msg()), vec!["a"]);
 
-        let config1 = ErrorConfig::new(&display_config, true, false);
+        let config1 = ErrorConfig::new(&display_config, true, false, true);
         assert!(errors.collect(&config1).shown.map(|x| x.msg()).is_empty());
     }
 
@@ -353,7 +366,8 @@ mod tests {
                 .collect(&ErrorConfig::new(
                     &ErrorDisplayConfig::default(),
                     false,
-                    false
+                    false,
+                    true,
                 ))
                 .shown
                 .map(|x| x.msg()),