mutmut 3.4.0__tar.gz → 3.5.0__tar.gz

{mutmut-3.4.0 → mutmut-3.5.0}/HISTORY.rst

@@ -1,6 +1,22 @@
 Changelog
 ---------
 
+3.5.0
+~~~~~
+
+* Filter mutants based on type annotations. This feature needs to be turned on with the `type_check_command` config.
+
+* Support running on Windows
+
+* Save mutation stats for use with CI/CD pipeline (#460)
+
+* Async functions fixed
+
+* Fix for functions with positional only arguments
+
+* Support signatures with PEP 649 deferred annotations
+
+
 3.4.0
 ~~~~~
 

{mutmut-3.4.0 → mutmut-3.5.0}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.4
 Name: mutmut
-Version: 3.4.0
+Version: 3.5.0
 Summary: mutation testing for Python 3
+Keywords: mutmut,mutant,mutation,test,testing
 Author: Anders Hovmöller
 Author-email: Anders Hovmöller <boxed@killingar.net>
 License-Expression: BSD-3-Clause
@@ -199,6 +200,34 @@ If you only want to mutate lines that are called (according to coverage.py), you
     mutate_only_covered_lines=true
 
 
+Filter generated mutants with type checker
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When your project is type checked using `mypy` or `pyrefly`, you can also use it to filter out invalid mutants.
+For instance, mutmut mutates `x: str = 'foo'` to `x: str = None` which can easily caught by type checkers.
+
+Using this filter can improve performance and reduce noise, however it can also hide a few relevant mutations:
+
+1. `x: str = None` may not be valid, but if your tests do not detect such a change it indicates that
+    the value of `x` is not properly tested (even if your type checker would catch this particular modification)
+2. In some edge cases with class properties (usually in the `__init__` method), the way `mypy` and `pyrefly` infer types does not work well
+    with the way mutmut mutates code. Some valid mutations like changing `self.x = 123` to `self.x = None` can
+    be filtered out, even though the may be valid.
+
+To enable this filtering, configure the `type_check_command` to output json results as follows:
+
+.. code-block::
+
+    # for pyrefly
+    type_check_command = ['pyrefly', 'check', '--output-format=json']
+    # for mypy
+    type_check_command = ['mypy', 'traces_parser', '--output', 'json']
+
+Currently, only `pyrefly` and `mypy` are supported.
+With `pyright` and `ty`, mutating a class method `Foo.bar()` can break the types of all methods of `Foo`,
+and therefore mutmut cannot match the type error with the mutant that caused the type error.
+
+
 Enable debug output (increase verbosity)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

{mutmut-3.4.0 → mutmut-3.5.0}/README.rst

@@ -167,6 +167,34 @@ If you only want to mutate lines that are called (according to coverage.py), you
     mutate_only_covered_lines=true
 
 
+Filter generated mutants with type checker
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When your project is type checked using `mypy` or `pyrefly`, you can also use it to filter out invalid mutants.
+For instance, mutmut mutates `x: str = 'foo'` to `x: str = None` which can easily caught by type checkers.
+
+Using this filter can improve performance and reduce noise, however it can also hide a few relevant mutations:
+
+1. `x: str = None` may not be valid, but if your tests do not detect such a change it indicates that
+    the value of `x` is not properly tested (even if your type checker would catch this particular modification)
+2. In some edge cases with class properties (usually in the `__init__` method), the way `mypy` and `pyrefly` infer types does not work well
+    with the way mutmut mutates code. Some valid mutations like changing `self.x = 123` to `self.x = None` can
+    be filtered out, even though the may be valid.
+
+To enable this filtering, configure the `type_check_command` to output json results as follows:
+
+.. code-block::
+
+    # for pyrefly
+    type_check_command = ['pyrefly', 'check', '--output-format=json']
+    # for mypy
+    type_check_command = ['mypy', 'traces_parser', '--output', 'json']
+
+Currently, only `pyrefly` and `mypy` are supported.
+With `pyright` and `ty`, mutating a class method `Foo.bar()` can break the types of all methods of `Foo`,
+and therefore mutmut cannot match the type error with the mutant that caused the type error.
+
+
 Enable debug output (increase verbosity)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

{mutmut-3.4.0 → mutmut-3.5.0}/pyproject.toml

@@ -1,8 +1,8 @@
 [project]
 name = "mutmut"
-version = "3.4.0"
+version = "3.5.0"
 description = "mutation testing for Python 3"
-keyowrds = ["mutmut", "mutant", "mutation", "test", "testing"]
+keywords = ["mutmut", "mutant", "mutation", "test", "testing"]
 authors = [
     { name = "Anders Hovmöller", email = "boxed@killingar.net" },
 ]
@@ -53,10 +53,17 @@ source-include = ["HISTORY.rst"]
 
 [dependency-groups]
 dev = [
+    "inline-snapshot>=0.32.0",
+    "pyrefly>=0.53.0",
     "pytest-asyncio>=1.0.0",
+    "ruff>=0.15.1",
 ]
 
 [tool.pytest.ini_options]
 testpaths = [
     "tests",
 ]
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.inline-snapshot]
+format-command="ruff format --stdin-filename {filename}"

{mutmut-3.4.0 → mutmut-3.5.0}/src/mutmut/__main__.py

@@ -1,3 +1,13 @@
+from typing import Iterable
+from mutmut.type_checking import TypeCheckingError
+from mutmut.type_checking import run_type_checker
+from typing import Any
+import os
+import sys
+import platform
+if platform.system() == 'Windows':
+    print('To run mutmut on Windows, please use the WSL. Native windows support is tracked in issue https://github.com/boxed/mutmut/issues/397')
+    sys.exit(1)
 import ast
 import fnmatch
 import gc
@@ -5,12 +15,10 @@ import inspect
 import itertools
 import json
 from multiprocessing import Pool, set_start_method, Lock
-import os
 import resource
 import shutil
 import signal
 import subprocess
-import sys
 from abc import ABC
 from collections import defaultdict
 from configparser import (
@@ -19,7 +27,7 @@ from configparser import (
     NoSectionError,
 )
 from contextlib import contextmanager
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import (
     datetime,
     timedelta,
@@ -43,12 +51,6 @@ from time import (
     process_time,
     sleep,
 )
-from typing import (
-    Dict,
-    List,
-    Union,
-    Optional,
-)
 import warnings
 
 import click
@@ -65,7 +67,6 @@ from mutmut.trampoline_templates import CLASS_NAME_SEPARATOR
 # Document: surviving mutants are retested when you ask mutmut to retest them, interactively in the UI or via command line
 
 # TODO: pragma no mutate should end up in `skipped` category
-# TODO: hash of function. If hash changes, retest all mutants as mutant IDs are not stable
 
 
 status_by_exit_code = defaultdict(lambda: 'suspicious', {
@@ -80,6 +81,7 @@ status_by_exit_code = defaultdict(lambda: 'suspicious', {
     34: 'skipped',
     35: 'suspicious',
     36: 'timeout',
+    37: 'caught by type check',
     -24: 'timeout',  # SIGXCPU
     24: 'timeout',  # SIGXCPU
     152: 'timeout',  # SIGXCPU
@@ -94,6 +96,7 @@ emoji_by_status = {
     'timeout': '⏰',
     'suspicious': '🤔',
     'skipped': '🔇',
+    'caught by type check': '🧙',
     'check was interrupted by user': '🛑',
     'not checked': '?',
     'killed': '🎉',
@@ -183,34 +186,56 @@ class BadTestExecutionCommandsException(Exception):
 
 
 class InvalidGeneratedSyntaxException(Exception):
-    def __init__(self, file: Union[Path, str]) -> None:
+    def __init__(self, file: Path | str) -> None:
         super().__init__(f'Mutmut generated invalid python syntax for {file}. '
                           'If the original file has valid python syntax, please file an issue '
                           'with a minimal reproducible example file.')
 
 
 def copy_src_dir():
-    for path in mutmut.config.paths_to_mutate:
-        output_path: Path = Path('mutants') / path
-        if isdir(path):
-            shutil.copytree(path, output_path, dirs_exist_ok=True)
+    for root, name in walk_all_files():
+        source_path = Path(root) / name
+        target_path = Path('mutants') / root / name
+        
+        if target_path.exists():
+            continue
+
+        if isdir(source_path):
+            shutil.copytree(source_path, target_path)
         else:
-            output_path.parent.mkdir(exist_ok=True, parents=True)
-            shutil.copyfile(path, output_path)
+            target_path.parent.mkdir(exist_ok=True, parents=True)
+            # copy mtime, so we later know that when source_mtime == target_mtime, the file is not (yet) mutated.
+            shutil.copy2(source_path, target_path)
 
 @dataclass
 class FileMutationResult:
     """Dataclass to transfer warnings and errors from child processes to the parent"""
-    warnings: list[Warning]
-    error: Optional[Exception] = None
+    warnings: list[Warning] = field(default_factory=list)
+    error: Exception | None = None
+    unmodified: bool = False
+    ignored: bool = False
 
-def create_mutants(max_children: int):
+@dataclass
+class MutantGenerationStats:
+    mutated: int = 0
+    unmodified: int = 0
+    ignored: int = 0
+
+def create_mutants(max_children: int) -> MutantGenerationStats:
+    stats = MutantGenerationStats()
     with Pool(processes=max_children) as p:
         for result in p.imap_unordered(create_file_mutants, walk_source_files()):
             for warning in result.warnings:
                 warnings.warn(warning)
             if result.error:
                 raise result.error
+            if result.unmodified:
+                stats.unmodified += 1
+            elif result.ignored:
+                stats.ignored += 1
+            else:
+                stats.mutated += 1
+    return stats
 
 def create_file_mutants(path: Path) -> FileMutationResult:
     try:
@@ -220,11 +245,11 @@ def create_file_mutants(path: Path) -> FileMutationResult:
 
         if mutmut.config.should_ignore_for_mutation(path):
             shutil.copy(path, output_path)
-            return FileMutationResult(warnings=[])
+            return FileMutationResult(ignored=True)
         else:
             return create_mutants_for_file(path, output_path)
     except Exception as e:
-        return FileMutationResult(warnings=[], error=e)
+        return FileMutationResult(error=e)
 
 def setup_source_paths():
     # ensure that the mutated source code can be imported by the tests
@@ -253,25 +278,43 @@ def copy_also_copy_files():
         if not path.exists():
             continue
         if path.is_file():
-            shutil.copy(path, destination)
+            shutil.copy2(path, destination)
         else:
             shutil.copytree(path, destination, dirs_exist_ok=True)
 
-def create_mutants_for_file(filename, output_path) -> FileMutationResult:
-    input_stat = os.stat(filename)
+def create_mutants_for_file(filename: Path, output_path: Path) -> FileMutationResult:
     warnings: list[Warning] = []
 
+    try:
+        source_mtime = os.path.getmtime(filename)
+        mutant_mtime = os.path.getmtime(output_path)
+        # We have three possible cases here:
+        # source_mtime > mutant_mtime: the source file was modified after the mutant has been created
+        # source_mtime == mutant_mtime: only copied, otherwise the mutant file is untouched
+        # source_mtime < mutant_mtime: the mutations have been saved after copying; source file untouched
+        if source_mtime < mutant_mtime:
+            # reset the mutation stats
+            source_file_mutation_data = SourceFileMutationData(path=filename)
+            source_file_mutation_data.load()
+            for key in source_file_mutation_data.exit_code_by_key:
+                source_file_mutation_data.exit_code_by_key[key] = None
+            source_file_mutation_data.save()
+
+            return FileMutationResult(unmodified=True)
+    except OSError:
+        pass
+
     with open(filename) as f:
         source = f.read()
 
     with open(output_path, 'w') as out:
         try:
-            mutant_names, hash_by_function_name = write_all_mutants_to_file(out=out, source=source, filename=filename)
+            mutant_names = write_all_mutants_to_file(out=out, source=source, filename=filename)
         except cst.ParserSyntaxError as e:
             # if libcst cannot parse it, then copy the source without any mutations
             warnings.append(SyntaxWarning(f'Unsupported syntax in {filename} ({str(e)}), skipping'))
             out.write(source)
-            mutant_names, hash_by_function_name = [], {}
+            mutant_names = []
 
     # validate no syntax errors of mutants
     with open(output_path) as f:
@@ -283,28 +326,27 @@ def create_mutants_for_file(filename, output_path) -> FileMutationResult:
             return FileMutationResult(warnings=warnings, error=invalid_syntax_error)
 
     source_file_mutation_data = SourceFileMutationData(path=filename)
-    module_name = strip_prefix(str(filename)[:-len(filename.suffix)].replace(os.sep, '.'), prefix='src.')
-
     source_file_mutation_data.exit_code_by_key = {
-         '.'.join([module_name, x]).replace('.__init__.', '.'): None
-        for x in mutant_names
+        get_mutant_name(filename, mutant_name): None for mutant_name in mutant_names
     }
-    source_file_mutation_data.hash_by_function_name = hash_by_function_name
-    assert None not in hash_by_function_name
     source_file_mutation_data.save()
 
-    os.utime(output_path, (input_stat.st_atime, input_stat.st_mtime))
     return FileMutationResult(warnings=warnings)
 
+def get_mutant_name(relative_source_path: Path, mutant_method_name: str) -> str:
+    module_name = str(relative_source_path)[:-len(relative_source_path.suffix)].replace(os.sep, '.')
+    module_name = strip_prefix(module_name, prefix='src.')
+
+    # FYI, we currently use "mutant_name" inconsistently, for both the whole identifier including the path and only the mangled method name
+    mutant_name = f'{module_name}.{mutant_method_name}'
+    mutant_name = mutant_name.replace('.__init__.', '.')
+    return mutant_name
 
 def write_all_mutants_to_file(*, out, source, filename):
     result, mutant_names = mutate_file_contents(filename, source, get_covered_lines_for_file(filename, mutmut._covered_lines))
     out.write(result)
 
-    # TODO: function hashes are currently not used. Reimplement this when needed.
-    hash_by_function_name = {}
-
-    return mutant_names, hash_by_function_name
+    return mutant_names
 
 
 class SourceFileMutationData:
@@ -315,7 +357,7 @@ class SourceFileMutationData:
         self.key_by_pid = {}
         self.exit_code_by_key = {}
         self.durations_by_key = {}
-        self.hash_by_function_name = {}
+        self.type_check_error_by_key: dict[str, str] = {}
         self.start_time_by_pid = {}
 
     def load(self):
@@ -326,10 +368,10 @@ class SourceFileMutationData:
             return
 
         self.exit_code_by_key = meta.pop('exit_code_by_key')
-        self.hash_by_function_name = meta.pop('hash_by_function_name')
         self.durations_by_key = meta.pop('durations_by_key')
         self.estimated_time_of_tests_by_mutant = meta.pop('estimated_durations_by_key')
-        assert not meta, f'Meta file {self.meta_path} constains unexpected keys: {set(meta.keys())}'
+        self.type_check_error_by_key = meta.pop('type_check_error_by_key')
+        assert not meta, f'Meta file {self.meta_path} contains unexpected keys: {set(meta.keys())}'
 
     def register_pid(self, *, pid, key):
         self.key_by_pid[pid] = key
@@ -355,11 +397,93 @@ class SourceFileMutationData:
         with open(self.meta_path, 'w') as f:
             json.dump(dict(
                 exit_code_by_key=self.exit_code_by_key,
-                hash_by_function_name=self.hash_by_function_name,
                 durations_by_key=self.durations_by_key,
+                type_check_error_by_key=self.type_check_error_by_key,
                 estimated_durations_by_key=self.estimated_time_of_tests_by_mutant,
             ), f, indent=4)
 
+def filter_mutants_with_type_checker():
+    with change_cwd(Path('mutants')):
+        errors = run_type_checker(mutmut.config.type_check_command)
+        errors_by_path = group_by_path(errors)
+
+        mutants_to_skip: dict[str, FailedTypeCheckMutant] = {}
+
+        for path, errors_of_file in errors_by_path.items():
+            with open(path, 'r', encoding='utf-8') as file:
+                source = file.read()
+            wrapper = cst.MetadataWrapper(cst.parse_module(source))
+            visitor = MutatedMethodsCollector(path)
+            wrapper.visit(visitor)
+            mutated_methods = visitor.found_mutants
+
+            for error in errors_of_file:
+                assert error.file_path == visitor.file
+                mutant = next((m for m in mutated_methods if m.line_number_start <= error.line_number <= m.line_number_end), None)
+                if mutant is None:
+                    raise Exception(f'Could not find mutant for type error {error.file_path}:{error.line_number} ({error.error_description}). '
+                                    'Probably, a code mutation influenced types in unexpected locations. '
+                                    'If your project normally has no type errors and uses mypy/pyrefly, please file an issue with steps to reproduce on github.')
+
+                mutant_name = get_mutant_name(path.relative_to(Path('.').absolute()), mutant.function_name)
+
+                mutants_to_skip[mutant_name] = FailedTypeCheckMutant(
+                    method_location=mutant,
+                    name=mutant_name,
+                    error=error,
+                )
+        
+        return mutants_to_skip
+
+
+def group_by_path(errors: list[TypeCheckingError]) -> dict[Path, list[TypeCheckingError]]:
+    grouped: dict[Path, list[TypeCheckingError]] = defaultdict(list)
+
+    for error in errors:
+        grouped[error.file_path].append(error)
+
+    return grouped
+
+@dataclass
+class MutatedMethodLocation:
+    file: Path
+    function_name: str
+    line_number_start: int
+    line_number_end: int
+
+
+@dataclass
+class FailedTypeCheckMutant:
+    method_location: MutatedMethodLocation
+    name: str
+    error: TypeCheckingError
+
+
+class MutatedMethodsCollector(cst.CSTVisitor):
+    METADATA_DEPENDENCIES = (cst.metadata.PositionProvider,)
+    
+    def __init__(self, file: Path):
+        self.file = file
+        self.found_mutants: list[MutatedMethodLocation] = []
+
+    def visit_FunctionDef(self, node: cst.FunctionDef) -> bool:
+        name = node.name.value
+        if is_mutated_method_name(name):
+            range = self.get_metadata(cst.metadata.PositionProvider, node)
+            self.found_mutants.append(MutatedMethodLocation(
+                file=self.file,
+                function_name=name,
+                line_number_start=range.start.line,
+                line_number_end=range.end.line,
+            ))
+
+        # do not continue visting children of this function
+        # mutated methods are not nested within other methods
+        return False
+
+def is_mutated_method_name(name: str):
+    return name.startswith(('x_', 'xǁ')) and '__mutmut' in name
+
 
 def unused(*_):
     pass
@@ -425,8 +549,8 @@ class ListAllTestsResult:
 
 class PytestRunner(TestRunner):
     def __init__(self):
-        self._pytest_add_cli_args: List[str] = mutmut.config.pytest_add_cli_args
-        self._pytest_add_cli_args_test_selection: List[str] = mutmut.config.pytest_add_cli_args_test_selection
+        self._pytest_add_cli_args: list[str] = mutmut.config.pytest_add_cli_args
+        self._pytest_add_cli_args_test_selection: list[str] = mutmut.config.pytest_add_cli_args_test_selection
 
         # tests_dir is a special case of a test selection option,
         # so also use pytest_add_cli_args_test_selection for the implementation
@@ -608,6 +732,7 @@ class Stat:
     timeout: int
     check_was_interrupted_by_user: int
     segfault: int
+    caught_by_type_check: int
 
 
 def collect_stat(m: SourceFileMutationData):
@@ -637,12 +762,13 @@ def calculate_summary_stats(source_file_mutation_data_by_path):
         timeout=sum(x.timeout for x in stats),
         check_was_interrupted_by_user=sum(x.check_was_interrupted_by_user for x in stats),
         segfault=sum(x.segfault for x in stats),
+        caught_by_type_check=sum(x.caught_by_type_check for x in stats),
     )
 
 
 def print_stats(source_file_mutation_data_by_path, force_output=False):
     s = calculate_summary_stats(source_file_mutation_data_by_path)
-    print_status(f'{(s.total - s.not_checked)}/{s.total}  🎉 {s.killed} 🫥 {s.no_tests}  ⏰ {s.timeout}  🤔 {s.suspicious}  🙁 {s.survived}  🔇 {s.skipped}', force_output=force_output)
+    print_status(f'{(s.total - s.not_checked)}/{s.total}  🎉 {s.killed} 🫥 {s.no_tests}  ⏰ {s.timeout}  🤔 {s.suspicious}  🙁 {s.survived}  🔇 {s.skipped}  🧙 {s.caught_by_type_check}', force_output=force_output)
 
 
 def run_forced_fail_test(runner):
@@ -709,15 +835,16 @@ class CatchOutput:
 
 @dataclass
 class Config:
-    also_copy: List[Path]
-    do_not_mutate: List[str]
+    also_copy: list[Path]
+    do_not_mutate: list[str]
     max_stack_depth: int
     debug: bool
-    paths_to_mutate: List[Path]
-    pytest_add_cli_args: List[str]
-    pytest_add_cli_args_test_selection: List[str]
-    tests_dir: List[str]
+    paths_to_mutate: list[Path]
+    pytest_add_cli_args: list[str]
+    pytest_add_cli_args_test_selection: list[str]
+    tests_dir: list[str]
     mutate_only_covered_lines: bool
+    type_check_command: list[str]
 
     def should_ignore_for_mutation(self, path):
         if not str(path).endswith('.py'):
@@ -754,7 +881,7 @@ def config_reader():
     config_parser = ConfigParser()
     config_parser.read('setup.cfg')
 
-    def s(key: str, default):
+    def s(key: str, default) -> Any:
         try:
             result = config_parser.get('mutmut', key)
         except (NoOptionError, NoSectionError):
@@ -790,6 +917,8 @@ def load_config():
             Path('test/'),
             Path('setup.cfg'),
             Path('pyproject.toml'),
+            Path('pytest.ini'),
+            Path('.gitignore'),
         ] + list(Path('.').glob('test*.py')),
         max_stack_depth=s('max_stack_depth', -1),
         debug=s('debug', False),
@@ -801,6 +930,7 @@ def load_config():
         tests_dir=s('tests_dir', []),
         pytest_add_cli_args=s('pytest_add_cli_args', []),
         pytest_add_cli_args_test_selection=s('pytest_add_cli_args_test_selection', []),
+        type_check_command=s('type_check_command', []),
     )
 
 
@@ -899,9 +1029,53 @@ def save_stats():
             stats_time=mutmut.stats_time,
         ), f, indent=4)
 
+def save_cicd_stats(source_file_mutation_data_by_path):
+    s = calculate_summary_stats(source_file_mutation_data_by_path)
+    with open('mutants/mutmut-cicd-stats.json', 'w') as f:
+        json.dump(dict(
+            killed=s.killed,
+            survived=s.survived,
+            total=s.total,
+            no_tests=s.no_tests,
+            skipped=s.skipped,
+            suspicious=s.suspicious,
+            timeout=s.timeout,
+            check_was_interrupted_by_user=s.check_was_interrupted_by_user,
+            segfault=s.segfault
+        ), f, indent=4)
+
+# exports CI/CD stats to block pull requests from merging if mutation score is too low, or used in other ways in CI/CD pipelines
+@cli.command()
+def export_cicd_stats():
+    ensure_config_loaded()
+
+    source_file_mutation_data_by_path: dict[str, SourceFileMutationData] = {}
+
+    for path in walk_source_files():
+        if mutmut.config.should_ignore_for_mutation(path):
+            continue
+
+        meta_path = Path('mutants') / (str(path) + '.meta')
+        if not meta_path.exists():
+            continue
+
+        m = SourceFileMutationData(path=path)
+        m.load()
+        if not m.exit_code_by_key:
+            continue
+
+        source_file_mutation_data_by_path[str(path)] = m
+
+    if not source_file_mutation_data_by_path:
+        print('No previous mutation data found. Run "mutmut run" first.')
+        return
+
+    save_cicd_stats(source_file_mutation_data_by_path)
+    print('Saved CI/CD stats to mutants/mutmut-cicd-stats.json')
+
 
 def collect_source_file_mutation_data(*, mutant_names):
-    source_file_mutation_data_by_path: Dict[str, SourceFileMutationData] = {}
+    source_file_mutation_data_by_path: dict[str, SourceFileMutationData] = {}
 
     for path in walk_source_files():
         if mutmut.config.should_ignore_for_mutation(path):
@@ -1006,7 +1180,7 @@ def run(mutant_names, *, max_children):
     _run(mutant_names, max_children)
 
 # separate function, so we can call it directly from the tests
-def _run(mutant_names: Union[tuple, list], max_children: Union[None, int]):
+def _run(mutant_names: tuple | list, max_children: None | int):
     # TODO: run no-ops once in a while to detect if we get false negatives
     # TODO: we should be able to get information on which tests killed mutants, which means we can get a list of tests and how many mutants each test kills. Those that kill zero mutants are redundant!
     os.environ['MUTANT_UNDER_TEST'] = 'mutant_generation'
@@ -1022,10 +1196,16 @@ def _run(mutant_names: Union[tuple, list], max_children: Union[None, int]):
         copy_also_copy_files()
         setup_source_paths()
         store_lines_covered_by_tests()            
-        create_mutants(max_children)
+        stats = create_mutants(max_children)
 
     time = datetime.now() - start
-    print(f'    done in {round(time.total_seconds()*1000)}ms', )
+    print(f'    done in {round(time.total_seconds()*1000)}ms ({stats.mutated} files mutated, {stats.ignored} ignored, {stats.unmodified} unmodified)', )
+
+    if mutmut.config.type_check_command:
+        with CatchOutput(spinner_title='Filtering mutations with type checker'):
+            mutants_caught_by_type_checker = filter_mutants_with_type_checker()
+    else:
+        mutants_caught_by_type_checker = {}
 
     # TODO: config/option for runner
     # runner = HammettRunner()
@@ -1061,7 +1241,7 @@ def _run(mutant_names: Union[tuple, list], max_children: Union[None, int]):
             print('    worker exit code', exit_code)
         source_file_mutation_data_by_pid[pid].register_result(pid=pid, exit_code=exit_code)
 
-    source_file_mutation_data_by_pid: Dict[int, SourceFileMutationData] = {}  # many pids map to one MutationData
+    source_file_mutation_data_by_pid: dict[int, SourceFileMutationData] = {}  # many pids map to one MutationData
     running_children = 0
     count_tried = 0
 
@@ -1095,12 +1275,18 @@ def _run(mutant_names: Union[tuple, list], max_children: Union[None, int]):
 
             tests = mutmut.tests_by_mangled_function_name.get(mangled_name_from_mutant_name(mutant_name), [])
 
-            # print(tests)
             if not tests:
                 m.exit_code_by_key[mutant_name] = 33
                 m.save()
                 continue
 
+            failed_type_check_mutant = mutants_caught_by_type_checker.get(mutant_name)
+            if failed_type_check_mutant:
+                m.exit_code_by_key[mutant_name] = 37
+                m.type_check_error_by_key[mutant_name] = failed_type_check_mutant.error.error_description
+                m.save()
+                continue
+
             pid = os.fork()
             if not pid:
                 # In the child
@@ -1205,7 +1391,7 @@ def read_orig_module(path) -> cst.Module:
         return cst.parse_module(f.read())
 
 
-def find_top_level_function_or_method(module: cst.Module, name: str) -> Union[cst.FunctionDef, None]:
+def find_top_level_function_or_method(module: cst.Module, name: str) -> cst.FunctionDef | None:
     name = name.split('.')[-1]
     for child in module.body:
         if isinstance(child, cst.FunctionDef) and child.name.value == name:
@@ -1315,7 +1501,7 @@ def apply_mutant(mutant_name):
 
 
 @cli.command()
-@click.option("--show-killed", is_flag=True, default=False, help="Display killed mutants.")
+@click.option("--show-killed", is_flag=True, default=False, help="Display mutants killed by tests and type checker.")
 def browse(show_killed):
     ensure_config_loaded()
 
@@ -1417,7 +1603,7 @@ def browse(show_killed):
                 source_file_mutation_data, stat = self.source_file_mutation_data_and_stat_by_path[event.row_key.value]
                 for k, v in source_file_mutation_data.exit_code_by_key.items():
                     status = status_by_exit_code[v]
-                    if status != 'killed' or show_killed:
+                    if status not in ('killed', 'caught by type check') or show_killed:
                         mutants_table.add_row(k, emoji_by_status[status], key=k)
             else:
                 assert event.data_table.id == 'mutants'
@@ -1432,6 +1618,7 @@ def browse(show_killed):
                 status = status_by_exit_code[exit_code]
                 estimated_duration = source_file_mutation_data.estimated_time_of_tests_by_mutant.get(mutant_name, '?')
                 duration = source_file_mutation_data.durations_by_key.get(mutant_name, '?')
+                type_check_error = source_file_mutation_data.type_check_error_by_key.get(mutant_name, '?')
 
                 view_tests_description = f'(press t to view tests executed for this mutant)'
 
@@ -1444,6 +1631,8 @@ def browse(show_killed):
                         description = f'Skipped ({exit_code=})'
                     case 'check was interrupted by user':
                         description = f'User interrupted ({exit_code=})'
+                    case 'caught by type check':
+                        description = f'Caught by type checker ({exit_code=}): {type_check_error}'
                     case 'timeout':
                         description = (f'Timeout ({exit_code=}): Timed out because tests did not finish within {duration:.3f} seconds. '
                                             f'Tests without mutation took {estimated_duration:.3f} seconds. {view_tests_description}')

{mutmut-3.4.0 → mutmut-3.5.0}/src/mutmut/code_coverage.py

@@ -2,7 +2,6 @@ import coverage
 import importlib
 import sys
 from pathlib import Path
-import json
 
 
 # Returns a set of lines that are covered in this file gvein the covered_lines dict

{mutmut-3.4.0 → mutmut-3.5.0}/src/mutmut/file_mutation.py

@@ -3,16 +3,14 @@
 from collections import defaultdict
 from collections.abc import Iterable, Sequence, Mapping
 from dataclasses import dataclass
-from pathlib import Path
 from typing import Union
-import warnings
 import libcst as cst
 from libcst.metadata import PositionProvider, MetadataWrapper
 import libcst.matchers as m
-from mutmut.trampoline_templates import build_trampoline, mangle_function_name, trampoline_impl
+from mutmut.trampoline_templates import create_trampoline_lookup, mangle_function_name, trampoline_impl
 from mutmut.node_mutation import mutation_operators, OPERATORS_TYPE
 
-NEVER_MUTATE_FUNCTION_NAMES = { "__getattribute__", "__setattr__", "__new__" }
+NEVER_MUTATE_FUNCTION_NAMES = { "__getattribute__", "__setattr__", "__new__"}
 NEVER_MUTATE_FUNCTION_CALLS = { "len", "isinstance" }
 
 @dataclass
@@ -236,6 +234,10 @@ def function_trampoline_arrangement(function: cst.FunctionDef, mutants: Iterable
     name = function.name.value
     mangled_name = mangle_function_name(name=name, class_name=class_name) + '__mutmut'
 
+    # trampoline with same signature, that forwards the calls to the activated mutant/original method
+    # (put first, s.t. it stays next to @overload definitions of this function. mypy needs this)
+    nodes.append(create_trampoline_wrapper(function, mangled_name, class_name))
+
     # copy of original function
     nodes.append(function.with_changes(name=cst.Name(mangled_name + '_orig')))
 
@@ -247,14 +249,88 @@ def function_trampoline_arrangement(function: cst.FunctionDef, mutants: Iterable
         mutated_method = deep_replace(mutated_method, mutant.original_node, mutant.mutated_node)
         nodes.append(mutated_method) # type: ignore
 
-    # trampoline that forwards the calls
-    trampoline = list(cst.parse_module(build_trampoline(orig_name=name, mutants=mutant_names, class_name=class_name)).body)
-    trampoline[0] = trampoline[0].with_changes(leading_lines=[cst.EmptyLine()])
-    nodes.extend(trampoline)
+    mutants_dict = list(cst.parse_module(create_trampoline_lookup(orig_name=name, mutants=mutant_names, class_name=class_name)).body)
+    mutants_dict[0] = mutants_dict[0].with_changes(leading_lines=[cst.EmptyLine()])
+
+    nodes.extend(mutants_dict)
 
     return nodes, mutant_names
 
 
+def create_trampoline_wrapper(function: cst.FunctionDef, mangled_name: str, class_name: str | None) -> cst.FunctionDef:
+    args: list[cst.Element | cst.StarredElement] = []
+    for pos_only_param in function.params.posonly_params:
+        args.append(cst.Element(pos_only_param.name))
+    for param in function.params.params:
+        args.append(cst.Element(param.name))
+    if isinstance(function.params.star_arg, cst.Param):
+        args.append(cst.StarredElement(function.params.star_arg.name))
+
+    if class_name is not None:
+        # remove self arg (handled by the trampoline function)
+        args = args[1:]
+
+    args_assignemnt = cst.Assign([cst.AssignTarget(cst.Name(value='args'))], cst.List(args))
+
+    kwargs: list[cst.DictElement | cst.StarredDictElement] = []
+    for param in function.params.kwonly_params:
+        kwargs.append(cst.DictElement(cst.SimpleString(f"'{param.name.value}'"), param.name))
+    if isinstance(function.params.star_kwarg, cst.Param):
+        kwargs.append(cst.StarredDictElement(function.params.star_kwarg.name))
+    
+    kwargs_assignment = cst.Assign([cst.AssignTarget(cst.Name(value='kwargs'))], cst.Dict(kwargs))
+
+    def _get_local_name(func_name: str) -> cst.BaseExpression:
+        # for top level, simply return the name
+        if class_name is None:
+            return cst.Name(func_name)
+        # for class methods, use object.__getattribute__(self, name)
+        return cst.Call(
+            func=cst.Attribute(cst.Name('object'), cst.Name('__getattribute__')),
+            args=[cst.Arg(cst.Name('self')), cst.Arg(cst.SimpleString(f"'{func_name}'"))]
+        )
+
+    result: cst.BaseExpression = cst.Call(
+        func=cst.Name('_mutmut_trampoline'),
+        args=[
+            cst.Arg(_get_local_name(f'{mangled_name}_orig')),
+            cst.Arg(_get_local_name(f'{mangled_name}_mutants')),
+            cst.Arg(cst.Name('args')),
+            cst.Arg(cst.Name('kwargs')),
+            cst.Arg(cst.Name('None' if class_name is None else 'self')),
+        ],
+    )
+    # for non-async functions, simply return the value or generator
+    result_statement = cst.SimpleStatementLine([cst.Return(result)])
+
+    if function.asynchronous:
+        is_generator = _is_generator(function)
+        if is_generator:
+            # async for i in _mutmut_trampoline(...): yield i
+            result_statement = cst.For(
+                target=cst.Name('i'),
+                iter=result,
+                body=cst.IndentedBlock([cst.SimpleStatementLine([cst.Expr(cst.Yield(cst.Name('i')))])]),
+                asynchronous=cst.Asynchronous(),
+            )
+        else:
+            # return await _mutmut_trampoline(...)
+            result_statement = cst.SimpleStatementLine([cst.Return(cst.Await(result))])
+
+    type_ignore_whitespace = cst.TrailingWhitespace(comment=cst.Comment('# type: ignore'))
+
+    function.whitespace_after_type_parameters
+    return function.with_changes(
+        body=cst.IndentedBlock(
+            [
+                cst.SimpleStatementLine([args_assignemnt], trailing_whitespace=type_ignore_whitespace),
+                cst.SimpleStatementLine([kwargs_assignment], trailing_whitespace=type_ignore_whitespace),
+                result_statement,
+            ],
+        ),
+    )
+
+
 def get_statements_until_func_or_class(statements: Sequence[MODULE_STATEMENT]) -> list[MODULE_STATEMENT]:
     """Get all statements until we encounter the first function or class definition"""
     result = []
@@ -302,3 +378,25 @@ class ChildReplacementTransformer(cst.CSTTransformer):
             self.replaced_node = True
             return self.new_node
         return updated_node
+
+def _is_generator(function: cst.FunctionDef) -> bool:
+    """Return True if the function has yield statement(s)."""
+    visitor = IsGeneratorVisitor(function)
+    function.visit(visitor)
+    return visitor.is_generator
+
+class IsGeneratorVisitor(cst.CSTVisitor):
+    """Check if a function is a generator.
+    We do so by checking if any child is a Yield statement, but not looking into inner function definitions."""
+    def __init__(self, original_function: cst.FunctionDef):
+        self.is_generator = False
+        self.original_function: cst.FunctionDef = original_function
+
+    def visit_FunctionDef(self, node):
+        # do not recurse into inner function definitions
+        if self.original_function != node:
+            return False
+
+    def visit_Yield(self, node):
+        self.is_generator = True
+        return False

mutmut-3.5.0/src/mutmut/trampoline_templates.py

@@ -0,0 +1,56 @@
+CLASS_NAME_SEPARATOR = 'ǁ'
+
+def create_trampoline_lookup(*, orig_name, mutants, class_name):
+    mangled_name = mangle_function_name(name=orig_name, class_name=class_name)
+
+    mutants_dict = f'{mangled_name}__mutmut_mutants : ClassVar[MutantDict] = {{ # type: ignore\n' + ', \n    '.join(f'{repr(m)}: {m}' for m in mutants) + '\n}'
+    return f"""
+{mutants_dict}
+{mangled_name}__mutmut_orig.__name__ = '{mangled_name}'
+"""
+
+def mangle_function_name(*, name, class_name):
+    assert CLASS_NAME_SEPARATOR not in name
+    if class_name:
+        assert CLASS_NAME_SEPARATOR not in class_name
+        prefix = f'x{CLASS_NAME_SEPARATOR}{class_name}{CLASS_NAME_SEPARATOR}'
+    else:
+        prefix = 'x_'
+    return f'{prefix}{name}'
+
+# noinspection PyUnresolvedReferences
+# language=python
+trampoline_impl = """
+from typing import Annotated
+from typing import Callable
+from typing import ClassVar
+
+MutantDict = Annotated[dict[str, Callable], "Mutant"] # type: ignore
+
+
+def _mutmut_trampoline(orig, mutants, call_args, call_kwargs, self_arg = None): # type: ignore
+    \"""Forward call to original or mutated function, depending on the environment\"""
+    import os # type: ignore
+    mutant_under_test = os.environ['MUTANT_UNDER_TEST'] # type: ignore
+    if mutant_under_test == 'fail': # type: ignore
+        from mutmut.__main__ import MutmutProgrammaticFailException # type: ignore
+        raise MutmutProgrammaticFailException('Failed programmatically')       # type: ignore
+    elif mutant_under_test == 'stats': # type: ignore
+        from mutmut.__main__ import record_trampoline_hit # type: ignore
+        record_trampoline_hit(orig.__module__ + '.' + orig.__name__) # type: ignore
+        # (for class methods, orig is bound and thus does not need the explicit self argument)
+        result = orig(*call_args, **call_kwargs) # type: ignore
+        return result # type: ignore
+    prefix = orig.__module__ + '.' + orig.__name__ + '__mutmut_' # type: ignore
+    if not mutant_under_test.startswith(prefix): # type: ignore
+        result = orig(*call_args, **call_kwargs) # type: ignore
+        return result # type: ignore
+    mutant_name = mutant_under_test.rpartition('.')[-1] # type: ignore
+    if self_arg is not None: # type: ignore
+        # call to a class method where self is not bound
+        result = mutants[mutant_name](self_arg, *call_args, **call_kwargs) # type: ignore
+    else:
+        result = mutants[mutant_name](*call_args, **call_kwargs) # type: ignore
+    return result # type: ignore
+
+"""

mutmut-3.5.0/src/mutmut/type_checking.py

@@ -0,0 +1,98 @@
+from typing import cast
+import json
+import subprocess
+from pathlib import Path
+from dataclasses import dataclass
+
+
+@dataclass
+class TypeCheckingError:
+    file_path: Path
+    line_number: int
+    """line number (first line is 1)"""
+    error_description: str
+
+
+def run_type_checker(type_check_command: list[str]) -> list[TypeCheckingError]:
+    errors = []
+
+    completed_process = subprocess.run(type_check_command, capture_output=True, encoding='utf-8')
+
+    try:
+        if 'mypy' in type_check_command:
+            report = [json.loads(line) for line in completed_process.stdout.splitlines()]
+        else:
+            report = json.loads(completed_process.stdout)
+    except json.JSONDecodeError as e:
+        raise Exception(f'type check command did not return JSON. Got: {completed_process.stdout} (stderr: {completed_process.stderr})')
+
+    if 'pyrefly' in type_check_command:
+        errors = parse_pyrefly_report(cast(dict, report))
+    elif 'mypy' in type_check_command:
+        errors = parse_mypy_report(report)
+    elif 'ty' in type_check_command:
+        errors = parse_ty_report(report)
+    else:
+        errors = parse_pyright_report(cast(dict, report))
+
+    return errors
+
+
+def parse_pyright_report(result: dict) -> list[TypeCheckingError]:
+    if not 'generalDiagnostics' in result:
+        raise Exception(f'Invalid pyright report. Could not find key "generalDiagnostics". Found: {set(result.keys())}')
+
+    errors = []
+    for diagnostic in result['generalDiagnostics']:
+        errors.append(TypeCheckingError(
+            file_path=Path(diagnostic['file']),
+            line_number=diagnostic['range']['start']['line'] + 1,
+            error_description=diagnostic['message'],
+        ))
+    
+    return errors
+        
+def parse_pyrefly_report(result: dict) -> list[TypeCheckingError]:
+    if not 'errors' in result:
+        raise Exception(f'Invalid pyrefly report. Could not find key "errors". Found: {set(result.keys())}')
+
+    errors = []
+
+    for error in result['errors']:
+        errors.append(TypeCheckingError(
+            file_path=Path(error['path']).absolute(),
+            line_number=error['line'],
+            error_description=error['concise_description'],
+        ))
+
+    return errors
+
+def parse_mypy_report(result: list[dict]) -> list[TypeCheckingError]:
+    errors = []
+
+    for diagnostic in result:
+        if diagnostic['severity'] != 'error':
+            continue
+        errors.append(TypeCheckingError(
+            file_path=Path(diagnostic['file']).absolute(),
+            line_number=diagnostic['line'],
+            error_description=diagnostic['message'],
+        ))
+
+    return errors
+
+def parse_ty_report(result: list[dict]) -> list[TypeCheckingError]:
+    errors = []
+
+    for diagnostic in result:
+        # assuming the gitlab code quality report format, these severities seem okay
+        # https://docs.gitlab.com/ci/testing/code_quality/#code-quality-report-format
+        if diagnostic['severity'] not in ('major', 'critical', 'blocker'):
+            continue
+        errors.append(TypeCheckingError(
+            file_path=Path(diagnostic['location']['path']).absolute(),
+            line_number=diagnostic['location']['positions']['begin']['line'],
+            error_description=diagnostic['description'],
+        ))
+
+    return errors

mutmut-3.4.0/src/mutmut/trampoline_templates.py

@@ -1,73 +0,0 @@
-CLASS_NAME_SEPARATOR = 'ǁ'
-
-def build_trampoline(*, orig_name, mutants, class_name):
-    mangled_name = mangle_function_name(name=orig_name, class_name=class_name)
-
-    mutants_dict = f'{mangled_name}__mutmut_mutants : ClassVar[MutantDict] = {{\n' + ', \n    '.join(f'{repr(m)}: {m}' for m in mutants) + '\n}'
-    access_prefix = ''
-    access_suffix = ''
-    self_arg = ''
-    if class_name is not None:
-        access_prefix = f'object.__getattribute__(self, "'
-        access_suffix = '")'
-        self_arg = ', self'
-
-    trampoline_name = '_mutmut_trampoline'
-
-    return f"""
-{mutants_dict}
-
-def {orig_name}({'self, ' if class_name is not None else ''}*args, **kwargs):
-    result = {trampoline_name}({access_prefix}{mangled_name}__mutmut_orig{access_suffix}, {access_prefix}{mangled_name}__mutmut_mutants{access_suffix}, args, kwargs{self_arg})
-    return result 
-
-{orig_name}.__signature__ = _mutmut_signature({mangled_name}__mutmut_orig)
-{mangled_name}__mutmut_orig.__name__ = '{mangled_name}'
-"""
-
-def mangle_function_name(*, name, class_name):
-    assert CLASS_NAME_SEPARATOR not in name
-    if class_name:
-        assert CLASS_NAME_SEPARATOR not in class_name
-        prefix = f'x{CLASS_NAME_SEPARATOR}{class_name}{CLASS_NAME_SEPARATOR}'
-    else:
-        prefix = 'x_'
-    return f'{prefix}{name}'
-
-# noinspection PyUnresolvedReferences
-# language=python
-trampoline_impl = """
-from inspect import signature as _mutmut_signature
-from typing import Annotated
-from typing import Callable
-from typing import ClassVar
-
-
-MutantDict = Annotated[dict[str, Callable], "Mutant"]
-
-
-def _mutmut_trampoline(orig, mutants, call_args, call_kwargs, self_arg = None):
-    \"""Forward call to original or mutated function, depending on the environment\"""
-    import os
-    mutant_under_test = os.environ['MUTANT_UNDER_TEST']
-    if mutant_under_test == 'fail':
-        from mutmut.__main__ import MutmutProgrammaticFailException
-        raise MutmutProgrammaticFailException('Failed programmatically')      
-    elif mutant_under_test == 'stats':
-        from mutmut.__main__ import record_trampoline_hit
-        record_trampoline_hit(orig.__module__ + '.' + orig.__name__)
-        result = orig(*call_args, **call_kwargs)
-        return result
-    prefix = orig.__module__ + '.' + orig.__name__ + '__mutmut_'
-    if not mutant_under_test.startswith(prefix):
-        result = orig(*call_args, **call_kwargs)
-        return result
-    mutant_name = mutant_under_test.rpartition('.')[-1]
-    if self_arg is not None:
-        # call to a class method where self is not bound
-        result = mutants[mutant_name](self_arg, *call_args, **call_kwargs)
-    else:
-        result = mutants[mutant_name](*call_args, **call_kwargs)
-    return result
-
-"""