propagate fixes, & simplify

Author: wyattscarpenter

mypy/build.py

@@ -876,10 +876,9 @@ def verbosity(self) -> int:
     def log(self, *message: str) -> None:
         if self.verbosity() >= 1:
             if message:
-                print("LOG: ", *message, file=self.stderr)
+                print("LOG: ", *message, file=self.stderr, flush=True)
             else:
-                print(file=self.stderr)
-            self.stderr.flush()
+                print(file=self.stderr, flush=True)
 
     def log_fine_grained(self, *message: str) -> None:
         import mypy.build
@@ -889,15 +888,13 @@ def log_fine_grained(self, *message: str) -> None:
         elif mypy.build.DEBUG_FINE_GRAINED:
             # Output log in a simplified format that is quick to browse.
             if message:
-                print(*message, file=self.stderr)
+                print(*message, file=self.stderr, flush=True)
             else:
-                print(file=self.stderr)
-            self.stderr.flush()
+                print(file=self.stderr, flush=True)
 
     def trace(self, *message: str) -> None:
         if self.verbosity() >= 2:
-            print("TRACE:", *message, file=self.stderr)
-            self.stderr.flush()
+            print("TRACE:", *message, file=self.stderr, flush=True)
 
     def add_stats(self, **kwds: Any) -> None:
         for key, value in kwds.items():

mypy/config_parser.py

@@ -322,7 +322,7 @@ def parse_config_file(
 
     If filename is None, fall back to default config files.
     """
-    stderr = stderr or sys.stderr
+    stderr = stderr if stderr is not None else sys.stderr
 
     ret = (
         _parse_individual_file(filename, stderr)

mypy/main.py

@@ -62,8 +62,8 @@ def stat_proxy(path: str) -> os.stat_result:
 def main(
     *,
     args: list[str] | None = None,
-    stdout: TextIO = sys.stdout,
-    stderr: TextIO = sys.stderr,
+    stdout: TextIO | None = None,
+    stderr: TextIO | None = None,
     clean_exit: bool = False,
 ) -> None:
     """Main entry point to the type checker.
@@ -74,6 +74,15 @@ def main(
         clean_exit: Don't hard kill the process on exit. This allows catching
             SystemExit.
     """
+    # As a common pattern around the codebase, we tend to do this instead of
+    # using default arguments that are mutable objects (due to Python's
+    # famously counterintuitive behavior about those): use a sentinel, then
+    # set.
+    stdout = stdout if stdout is not None else sys.stdout
+    stderr = stderr if stderr is not None else sys.stderr
+    # sys.stdout and sys.stderr might technically be None, but this fact isn't
+    # currently enforced by the stubs (they are marked as MaybeNone (=Any)).
+
     util.check_python_version("mypy")
     t0 = time.time()
     # To log stat() calls: os.stat = stat_proxy
@@ -150,11 +159,10 @@ def main(
             summary = formatter.format_error(
                 n_errors, n_files, len(sources), blockers=blockers, use_color=options.color_output
             )
-            stdout.write(summary + "\n")
+            print(summary, file=stdout, flush=True)
         # Only notes should also output success
         elif not messages or n_notes == len(messages):
-            stdout.write(formatter.format_success(len(sources), options.color_output) + "\n")
-        stdout.flush()
+            print(formatter.format_success(len(sources), options.color_output), file=stdout, flush=True)
 
     if options.install_types and not options.non_interactive:
         result = install_types(formatter, options, after_run=True, non_interactive=False)
@@ -180,13 +188,14 @@ def run_build(
     options: Options,
     fscache: FileSystemCache,
     t0: float,
-    stdout: TextIO,
-    stderr: TextIO,
+    stdout: TextIO | None = None,
+    stderr: TextIO | None = None,
 ) -> tuple[build.BuildResult | None, list[str], bool]:
     formatter = util.FancyFormatter(
         stdout, stderr, options.hide_error_codes, hide_success=bool(options.output)
     )
-
+    stdout = stdout if stdout is not None else sys.stdout
+    stderr = stderr if stderr is not None else sys.stderr
     messages = []
     messages_by_file = defaultdict(list)
 
@@ -238,14 +247,12 @@ def flush_errors(filename: str | None, new_messages: list[str], serious: bool) -
 
 
 def show_messages(
-    messages: list[str], f: TextIO, formatter: util.FancyFormatter, options: Options
+    messages: list[str], f: TextIO | None, formatter: util.FancyFormatter, options: Options
 ) -> None:
     for msg in messages:
         if options.color_output:
             msg = formatter.colorize(msg)
-        f.write(msg + "\n")
-    f.flush()
-
+        print(msg, file=f, flush=True)
 
 # Make the help output a little less jarring.
 class AugmentedHelpFormatter(argparse.RawDescriptionHelpFormatter):
@@ -399,7 +406,7 @@ def _print_message(self, message: str, file: SupportsWrite[str] | None = None) -
         if message:
             if file is None:
                 file = self.stderr
-            file.write(message)
+            print(message, file=file)
 
     # ===============
     # Exiting methods
@@ -465,8 +472,8 @@ def __call__(
 def define_options(
     program: str = "mypy",
     header: str = HEADER,
-    stdout: TextIO | None,
-    stderr: TextIO | None,
+    stdout: TextIO | None = None,
+    stderr: TextIO | None = None,
     server_options: bool = False,
 ) -> tuple[CapturableArgumentParser, list[str], list[tuple[str, bool]]]:
     """Define the options in the parser (by calling a bunch of methods that express/build our desired command-line flags).

mypy/util.py

@@ -592,7 +592,7 @@ class FancyFormatter:
     """
 
     def __init__(
-        self, f_out: IO[str], f_err: IO[str], hide_error_codes: bool, hide_success: bool = False
+        self, f_out: IO[str] | None, f_err: IO[str] | None, hide_error_codes: bool, hide_success: bool = False
     ) -> None:
         self.hide_error_codes = hide_error_codes
         self.hide_success = hide_success
@@ -601,7 +601,7 @@ def __init__(
         if sys.platform not in ("linux", "darwin", "win32", "emscripten"):
             self.dummy_term = True
             return
-        if not should_force_color() and (not f_out.isatty() or not f_err.isatty()):
+        if (f_out is None or f_err is None) or not should_force_color() and (not f_out.isatty() or not f_err.isatty()):
             self.dummy_term = True
             return
         if sys.platform == "win32":