jaclang 0.4.6__py3-none-any.whl → 0.5.0__py3-none-any.whl

jaclang/vendor/mypy/expandtype.py

@@ -50,18 +50,15 @@ import mypy.type_visitor  # ruff: isort: skip
 
 
 @overload
-def expand_type(typ: CallableType, env: Mapping[TypeVarId, Type]) -> CallableType:
-    ...
+def expand_type(typ: CallableType, env: Mapping[TypeVarId, Type]) -> CallableType: ...
 
 
 @overload
-def expand_type(typ: ProperType, env: Mapping[TypeVarId, Type]) -> ProperType:
-    ...
+def expand_type(typ: ProperType, env: Mapping[TypeVarId, Type]) -> ProperType: ...
 
 
 @overload
-def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type:
-    ...
+def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type: ...
 
 
 def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type:
@@ -72,18 +69,15 @@ def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type:
 
 
 @overload
-def expand_type_by_instance(typ: CallableType, instance: Instance) -> CallableType:
-    ...
+def expand_type_by_instance(typ: CallableType, instance: Instance) -> CallableType: ...
 
 
 @overload
-def expand_type_by_instance(typ: ProperType, instance: Instance) -> ProperType:
-    ...
+def expand_type_by_instance(typ: ProperType, instance: Instance) -> ProperType: ...
 
 
 @overload
-def expand_type_by_instance(typ: Type, instance: Instance) -> Type:
-    ...
+def expand_type_by_instance(typ: Type, instance: Instance) -> Type: ...
 
 
 def expand_type_by_instance(typ: Type, instance: Instance) -> Type:
@@ -286,6 +280,8 @@ class ExpandTypeVisitor(TrivialSyntheticTypeTranslator):
     def expand_unpack(self, t: UnpackType) -> list[Type]:
         assert isinstance(t.type, TypeVarTupleType)
         repl = get_proper_type(self.variables.get(t.type.id, t.type))
+        if isinstance(repl, UnpackType):
+            repl = get_proper_type(repl.type)
         if isinstance(repl, TupleType):
             return repl.items
         elif (
@@ -312,20 +308,24 @@ class ExpandTypeVisitor(TrivialSyntheticTypeTranslator):
         suffix = self.expand_types(t.arg_types[star_index + 1 :])
 
         var_arg_type = get_proper_type(var_arg.type)
-        # We have something like Unpack[Tuple[Unpack[Ts], X1, X2]]
-        if isinstance(var_arg_type, TupleType):
-            expanded_tuple = var_arg_type.accept(self)
-            assert isinstance(expanded_tuple, ProperType) and isinstance(
-                expanded_tuple, TupleType
-            )
-            expanded_items = expanded_tuple.items
-            fallback = var_arg_type.partial_fallback
+        if isinstance(var_arg_type, Instance):
+            # we have something like Unpack[Tuple[Any, ...]]
+            new_unpack = var_arg
         else:
-            # We have plain Unpack[Ts]
-            assert isinstance(var_arg_type, TypeVarTupleType)
-            fallback = var_arg_type.tuple_fallback
-            expanded_items = self.expand_unpack(var_arg)
-        new_unpack = UnpackType(TupleType(expanded_items, fallback))
+            if isinstance(var_arg_type, TupleType):
+                # We have something like Unpack[Tuple[Unpack[Ts], X1, X2]]
+                expanded_tuple = var_arg_type.accept(self)
+                assert isinstance(expanded_tuple, ProperType) and isinstance(
+                    expanded_tuple, TupleType
+                )
+                expanded_items = expanded_tuple.items
+                fallback = var_arg_type.partial_fallback
+            else:
+                # We have plain Unpack[Ts]
+                assert isinstance(var_arg_type, TypeVarTupleType), type(var_arg_type)
+                fallback = var_arg_type.tuple_fallback
+                expanded_items = self.expand_unpack(var_arg)
+            new_unpack = UnpackType(TupleType(expanded_items, fallback))
         return prefix + [new_unpack] + suffix
 
     def visit_callable_type(self, t: CallableType) -> CallableType:
@@ -481,13 +481,13 @@ class ExpandTypeVisitor(TrivialSyntheticTypeTranslator):
 
 
 @overload
-def expand_self_type(var: Var, typ: ProperType, replacement: ProperType) -> ProperType:
-    ...
+def expand_self_type(
+    var: Var, typ: ProperType, replacement: ProperType
+) -> ProperType: ...
 
 
 @overload
-def expand_self_type(var: Var, typ: Type, replacement: Type) -> Type:
-    ...
+def expand_self_type(var: Var, typ: Type, replacement: Type) -> Type: ...
 
 
 def expand_self_type(var: Var, typ: Type, replacement: Type) -> Type:

jaclang/vendor/mypy/fastparse.py

@@ -126,7 +126,18 @@ PY_MINOR_VERSION: Final = sys.version_info[1]
 import ast as ast3
 
 # TODO: Index, ExtSlice are deprecated in 3.9.
-from ast import AST, Attribute, Call, FunctionType, Index, Name, Starred, UnaryOp, USub
+from ast import (
+    AST,
+    Attribute,
+    Call,
+    FunctionType,
+    Index,
+    Name,
+    Starred,
+    UAdd,
+    UnaryOp,
+    USub,
+)
 
 
 def ast3_parse(
@@ -193,7 +204,7 @@ def parse(
     source: str | bytes,
     fnam: str,
     module: str | None,
-    errors: Errors | None = None,
+    errors: Errors,
     options: Options | None = None,
 ) -> MypyFile:
     """Parse a source file, without doing any semantic analysis.
@@ -202,18 +213,15 @@ def parse(
     on failure. Otherwise, use the errors object to report parse errors.
     """
     ignore_errors = (options is not None and options.ignore_errors) or (
-        errors is not None and fnam in errors.ignored_files
+        fnam in errors.ignored_files
     )
     # If errors are ignored, we can drop many function bodies to speed up type checking.
     strip_function_bodies = ignore_errors and (
         options is None or not options.preserve_asts
     )
-    raise_on_error = False
+
     if options is None:
         options = Options()
-    if errors is None:
-        errors = Errors(options)
-        raise_on_error = True
     errors.set_file(fnam, module, options=options)
     is_stub_file = fnam.endswith(".pyi")
     if is_stub_file:
@@ -236,11 +244,9 @@ def parse(
             options=options,
             is_stub=is_stub_file,
             errors=errors,
-            ignore_errors=ignore_errors,
             strip_function_bodies=strip_function_bodies,
+            path=fnam,
         ).visit(ast)
-        tree.path = fnam
-        tree.is_stub = is_stub_file
     except SyntaxError as e:
         # alias to please mypyc
         is_py38_or_earlier = sys.version_info < (3, 9)
@@ -266,9 +272,6 @@ def parse(
         )
         tree = MypyFile([], [], False, {})
 
-    if raise_on_error and errors.is_errors():
-        errors.raise_error()
-
     assert isinstance(tree, MypyFile)
     return tree
 
@@ -344,7 +347,7 @@ def parse_type_string(
     """
     try:
         _, node = parse_type_comment(
-            expr_string.strip(), line=line, column=column, errors=None
+            f"({expr_string})", line=line, column=column, errors=None
         )
         if isinstance(node, UnboundType) and node.original_str_expr is None:
             node.original_str_expr = expr_string
@@ -376,8 +379,8 @@ class ASTConverter:
         is_stub: bool,
         errors: Errors,
         *,
-        ignore_errors: bool,
         strip_function_bodies: bool,
+        path: str,
     ) -> None:
         # 'C' for class, 'D' for function signature, 'F' for function, 'L' for lambda
         self.class_and_function_stack: list[Literal["C", "D", "F", "L"]] = []
@@ -386,8 +389,8 @@ class ASTConverter:
         self.options = options
         self.is_stub = is_stub
         self.errors = errors
-        self.ignore_errors = ignore_errors
         self.strip_function_bodies = strip_function_bodies
+        self.path = path
 
         self.type_ignores: dict[int, list[str]] = {}
 
@@ -401,6 +404,10 @@ class ASTConverter:
         self, msg: ErrorMessage, line: int, column: int, blocker: bool = True
     ) -> None:
         if blocker or not self.options.ignore_errors:
+            # Make sure self.errors reflects any type ignores that we have parsed
+            self.errors.set_file_ignored_lines(
+                self.path, self.type_ignores, self.options.ignore_errors
+            )
             self.errors.report(line, column, msg.value, blocker=blocker, code=msg.code)
 
     def fail_merge_overload(self, node: IfStmt) -> None:
@@ -908,10 +915,15 @@ class ASTConverter:
                 self.fail(
                     message_registry.INVALID_TYPE_IGNORE, ti.lineno, -1, blocker=False
                 )
+
         body = self.fix_function_overloads(
             self.translate_stmt_list(mod.body, ismodule=True)
         )
-        return MypyFile(body, self.imports, False, self.type_ignores)
+
+        ret = MypyFile(body, self.imports, False, ignored_lines=self.type_ignores)
+        ret.is_stub = self.is_stub
+        ret.path = self.path
+        return ret
 
     # --- stmt ---
     # FunctionDef(identifier name, arguments args,
@@ -967,9 +979,11 @@ class ASTConverter:
                             n.col_offset,
                         )
                     arg_types = [
-                        a.type_annotation
-                        if a.type_annotation is not None
-                        else AnyType(TypeOfAny.unannotated)
+                        (
+                            a.type_annotation
+                            if a.type_annotation is not None
+                            else AnyType(TypeOfAny.unannotated)
+                        )
                         for a in args
                     ]
                 else:
@@ -1056,9 +1070,11 @@ class ASTConverter:
                     ],
                     arg_kinds,
                     arg_names,
-                    return_type
-                    if return_type is not None
-                    else AnyType(TypeOfAny.unannotated),
+                    (
+                        return_type
+                        if return_type is not None
+                        else AnyType(TypeOfAny.unannotated)
+                    ),
                     _dummy_fallback,
                 )
 
@@ -1905,12 +1921,10 @@ class TypeConverter:
         )
 
     @overload
-    def visit(self, node: ast3.expr) -> ProperType:
-        ...
+    def visit(self, node: ast3.expr) -> ProperType: ...
 
     @overload
-    def visit(self, node: AST | None) -> ProperType | None:
-        ...
+    def visit(self, node: AST | None) -> ProperType | None: ...
 
     def visit(self, node: AST | None) -> ProperType | None:
         """Modified visit -- keep track of the stack of nodes"""
@@ -2071,13 +2085,19 @@ class TypeConverter:
 
     # UnaryOp(op, operand)
     def visit_UnaryOp(self, n: UnaryOp) -> Type:
-        # We support specifically Literal[-4] and nothing else.
-        # For example, Literal[+4] or Literal[~6] is not supported.
+        # We support specifically Literal[-4], Literal[+4], and nothing else.
+        # For example, Literal[~6] or Literal[not False] is not supported.
         typ = self.visit(n.operand)
-        if isinstance(typ, RawExpressionType) and isinstance(n.op, USub):
-            if isinstance(typ.literal_value, int):
+        if (
+            isinstance(typ, RawExpressionType)
+            # Use type() because we do not want to allow bools.
+            and type(typ.literal_value) is int  # noqa: E721
+        ):
+            if isinstance(n.op, USub):
                 typ.literal_value *= -1
                 return typ
+            if isinstance(n.op, UAdd):
+                return typ
         return self.invalid_type(n)
 
     def numeric_type(self, value: object, n: AST) -> Type:

jaclang/vendor/mypy/inspections.py

@@ -563,9 +563,11 @@ class InspectionEngine:
         self.module = state
         return (
             state,
-            {"out": f"Unknown module: {file}", "err": "", "status": 1}
-            if state is None
-            else {},
+            (
+                {"out": f"Unknown module: {file}", "err": "", "status": 1}
+                if state is None
+                else {}
+            ),
         )
 
     def run_inspection(

jaclang/vendor/mypy/join.py

@@ -244,13 +244,13 @@ def trivial_join(s: Type, t: Type) -> Type:
 @overload
 def join_types(
     s: ProperType, t: ProperType, instance_joiner: InstanceJoiner | None = None
-) -> ProperType:
-    ...
+) -> ProperType: ...
 
 
 @overload
-def join_types(s: Type, t: Type, instance_joiner: InstanceJoiner | None = None) -> Type:
-    ...
+def join_types(
+    s: Type, t: Type, instance_joiner: InstanceJoiner | None = None
+) -> Type: ...
 
 
 def join_types(s: Type, t: Type, instance_joiner: InstanceJoiner | None = None) -> Type:

jaclang/vendor/mypy/main.py

@@ -173,7 +173,7 @@ def main(
         sys.exit(code)
 
     # HACK: keep res alive so that mypyc won't free it before the hard_exit
-    list([res])
+    list([res])  # noqa: C410
 
 
 def run_build(
@@ -377,14 +377,13 @@ FOOTER: Final = """Environment variables:
 
 
 class CapturableArgumentParser(argparse.ArgumentParser):
-
     """Override ArgumentParser methods that use sys.stdout/sys.stderr directly.
 
     This is needed because hijacking sys.std* is not thread-safe,
     yet output must be captured to properly support mypy.api.run.
     """
 
-    def __init__(self, *args: Any, **kwargs: Any):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         self.stdout = kwargs.pop("stdout", sys.stdout)
         self.stderr = kwargs.pop("stderr", sys.stderr)
         super().__init__(*args, **kwargs)
@@ -431,7 +430,6 @@ class CapturableArgumentParser(argparse.ArgumentParser):
 
 
 class CapturableVersionAction(argparse.Action):
-
     """Supplement CapturableArgumentParser to handle --version.
 
     This is nearly identical to argparse._VersionAction except,
@@ -450,7 +448,7 @@ class CapturableVersionAction(argparse.Action):
         default: str = argparse.SUPPRESS,
         help: str = "show program's version number and exit",
         stdout: IO[str] | None = None,
-    ):
+    ) -> None:
         super().__init__(
             option_strings=option_strings,
             dest=dest,
@@ -1067,7 +1065,7 @@ def process_options(
     parser.add_argument(
         "--enable-incomplete-feature",
         action="append",
-        metavar="FEATURE",
+        metavar="{" + ",".join(sorted(INCOMPLETE_FEATURES)) + "}",
         help="Enable support of incomplete/experimental features for early preview",
     )
     internals_group.add_argument(
@@ -1207,6 +1205,8 @@ def process_options(
     parser.add_argument(
         "--semantic-analysis-only", action="store_true", help=argparse.SUPPRESS
     )
+    # Some tests use this to tell mypy that we are running a test.
+    parser.add_argument("--test-env", action="store_true", help=argparse.SUPPRESS)
     # --local-partial-types disallows partial types spanning module top level and a function
     # (implicitly defined in fine-grained incremental mode)
     parser.add_argument(

jaclang/vendor/mypy/message_registry.py

@@ -58,8 +58,7 @@ RETURN_IN_ASYNC_GENERATOR: Final = ErrorMessage(
     '"return" with value in async generator is not allowed'
 )
 INVALID_RETURN_TYPE_FOR_GENERATOR: Final = ErrorMessage(
-    'The return type of a generator function should be "Generator"'
-    " or one of its supertypes"
+    'The return type of a generator function should be "Generator" or one of its supertypes'
 )
 INVALID_RETURN_TYPE_FOR_ASYNC_GENERATOR: Final = ErrorMessage(
     'The return type of an async generator function should be "AsyncGenerator" or one of its '

jaclang/vendor/mypy/messages.py

@@ -1458,22 +1458,27 @@ class MessageBuilder:
         return target
 
     def incompatible_type_application(
-        self, expected_arg_count: int, actual_arg_count: int, context: Context
+        self,
+        min_arg_count: int,
+        max_arg_count: int,
+        actual_arg_count: int,
+        context: Context,
     ) -> None:
-        if expected_arg_count == 0:
+        if max_arg_count == 0:
             self.fail(
                 "Type application targets a non-generic function or class", context
             )
-        elif actual_arg_count > expected_arg_count:
-            self.fail(
-                f"Type application has too many types ({expected_arg_count} expected)",
-                context,
-            )
+            return
+
+        if min_arg_count == max_arg_count:
+            s = f"{max_arg_count} expected"
         else:
-            self.fail(
-                f"Type application has too few types ({expected_arg_count} expected)",
-                context,
-            )
+            s = f"expected between {min_arg_count} and {max_arg_count}"
+
+        if actual_arg_count > max_arg_count:
+            self.fail(f"Type application has too many types ({s})", context)
+        else:
+            self.fail(f"Type application has too few types ({s})", context)
 
     def could_not_infer_type_arguments(
         self, callee_type: CallableType, n: int, context: Context
@@ -2267,7 +2272,7 @@ class MessageBuilder:
     def impossible_intersection(
         self, formatted_base_class_list: str, reason: str, context: Context
     ) -> None:
-        template = "Subclass of {} cannot exist: would have {}"
+        template = "Subclass of {} cannot exist: {}"
         self.fail(
             template.format(formatted_base_class_list, reason),
             context,
@@ -2786,10 +2791,10 @@ def format_type_inner(
         else:
             base_str = itype.type.name
         if not itype.args:
-            if not itype.type.has_type_var_tuple_type:
-                # No type arguments, just return the type name
-                return base_str
-            return base_str + "[()]"
+            if itype.type.has_type_var_tuple_type and len(itype.type.type_vars) == 1:
+                return base_str + "[()]"
+            # No type arguments, just return the type name
+            return base_str
         elif itype.type.fullname == "builtins.tuple":
             item_type_str = format(itype.args[0])
             return f"{'tuple' if options.use_lowercase_names() else 'Tuple'}[{item_type_str}, ...]"
@@ -3326,12 +3331,15 @@ def for_function(callee: CallableType) -> str:
     return ""
 
 
-def wrong_type_arg_count(n: int, act: str, name: str) -> str:
-    s = f"{n} type arguments"
-    if n == 0:
-        s = "no type arguments"
-    elif n == 1:
-        s = "1 type argument"
+def wrong_type_arg_count(low: int, high: int, act: str, name: str) -> str:
+    if low == high:
+        s = f"{low} type arguments"
+        if low == 0:
+            s = "no type arguments"
+        elif low == 1:
+            s = "1 type argument"
+    else:
+        s = f"between {low} and {high} type arguments"
     if act == "0":
         act = "none"
     return f'"{name}" expects {s}, but {act} given'
@@ -3413,7 +3421,7 @@ def append_invariance_notes(
     ):
         invariant_type = "Dict"
         covariant_suggestion = (
-            'Consider using "Mapping" instead, ' "which is covariant in the value type"
+            'Consider using "Mapping" instead, which is covariant in the value type'
         )
     if invariant_type and covariant_suggestion:
         notes.append(

jaclang/vendor/mypy/metastore.py

@@ -63,8 +63,7 @@ class MetadataStore:
         """
 
     @abstractmethod
-    def list_all(self) -> Iterable[str]:
-        ...
+    def list_all(self) -> Iterable[str]: ...
 
 
 def random_string() -> str:

jaclang/vendor/mypy/modulefinder.py

@@ -13,18 +13,11 @@ import re
 import subprocess
 import sys
 from enum import Enum, unique
-
-from mypy.errors import CompileError
-
-if sys.version_info >= (3, 11):
-    import tomllib
-else:
-    import tomli as tomllib
-
 from typing import Dict, Final, List, NamedTuple, Optional, Tuple, Union
 from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy import pyinfo
+from mypy.errors import CompileError
 from mypy.fscache import FileSystemCache
 from mypy.nodes import MypyFile
 from mypy.options import Options
@@ -444,7 +437,7 @@ class FindModuleCache:
         for pkg_dir in self.search_paths.package_path:
             stub_name = components[0] + "-stubs"
             stub_dir = os.path.join(pkg_dir, stub_name)
-            if fscache.isdir(stub_dir) and self._is_compatible_stub_package(stub_dir):
+            if fscache.isdir(stub_dir):
                 stub_typed_file = os.path.join(stub_dir, "py.typed")
                 stub_components = [stub_name] + components[1:]
                 path = os.path.join(pkg_dir, *stub_components[:-1])
@@ -586,19 +579,6 @@ class FindModuleCache:
         else:
             return ModuleNotFoundReason.NOT_FOUND
 
-    def _is_compatible_stub_package(self, stub_dir: str) -> bool:
-        """Does a stub package support the target Python version?
-
-        Stub packages may contain a metadata file which specifies
-        whether the stubs are compatible with Python 2 and 3.
-        """
-        metadata_fnam = os.path.join(stub_dir, "METADATA.toml")
-        if not os.path.isfile(metadata_fnam):
-            return True
-        with open(metadata_fnam, "rb") as f:
-            metadata = tomllib.load(f)
-        return bool(metadata.get("python3", True))
-
     def find_modules_recursive(self, module: str) -> list[BuildSource]:
         module_path = self.find_module(module)
         if isinstance(module_path, ModuleNotFoundReason):

jaclang/vendor/mypy/nodes.py

@@ -419,7 +419,9 @@ class ImportBase(Statement):
 
     __slots__ = ("is_unreachable", "is_top_level", "is_mypy_only", "assignments")
 
-    is_unreachable: bool  # Set by semanal.SemanticAnalyzerPass1 if inside `if False` etc.
+    is_unreachable: (
+        bool  # Set by semanal.SemanticAnalyzerPass1 if inside `if False` etc.
+    )
     is_top_level: bool  # Ditto if outside any class or def
     is_mypy_only: bool  # Ditto if inside `if TYPE_CHECKING` or `if MYPY`
 
@@ -1178,7 +1180,7 @@ class ClassDef(Statement):
         }
 
     @classmethod
-    def deserialize(self, data: JsonDict) -> ClassDef:
+    def deserialize(cls, data: JsonDict) -> ClassDef:
         assert data[".class"] == "ClassDef"
         res = ClassDef(
             data["name"],
@@ -3201,7 +3203,7 @@ class TypeInfo(SymbolNode):
                     if name in EXCLUDED_PROTOCOL_ATTRIBUTES:
                         continue
                     members.add(name)
-        return sorted(list(members))
+        return sorted(members)
 
     def __getitem__(self, name: str) -> SymbolTableNode:
         n = self.get(name)
@@ -3348,30 +3350,30 @@ class TypeInfo(SymbolNode):
             "bases": [b.serialize() for b in self.bases],
             "mro": [c.fullname for c in self.mro],
             "_promote": [p.serialize() for p in self._promote],
-            "alt_promote": None
-            if self.alt_promote is None
-            else self.alt_promote.serialize(),
+            "alt_promote": (
+                None if self.alt_promote is None else self.alt_promote.serialize()
+            ),
             "declared_metaclass": (
                 None
                 if self.declared_metaclass is None
                 else self.declared_metaclass.serialize()
             ),
-            "metaclass_type": None
-            if self.metaclass_type is None
-            else self.metaclass_type.serialize(),
-            "tuple_type": None
-            if self.tuple_type is None
-            else self.tuple_type.serialize(),
-            "typeddict_type": None
-            if self.typeddict_type is None
-            else self.typeddict_type.serialize(),
+            "metaclass_type": (
+                None if self.metaclass_type is None else self.metaclass_type.serialize()
+            ),
+            "tuple_type": (
+                None if self.tuple_type is None else self.tuple_type.serialize()
+            ),
+            "typeddict_type": (
+                None if self.typeddict_type is None else self.typeddict_type.serialize()
+            ),
             "flags": get_flags(self, TypeInfo.FLAGS),
             "metadata": self.metadata,
-            "slots": list(sorted(self.slots)) if self.slots is not None else None,
+            "slots": sorted(self.slots) if self.slots is not None else None,
             "deletable_attributes": self.deletable_attributes,
-            "self_type": self.self_type.serialize()
-            if self.self_type is not None
-            else None,
+            "self_type": (
+                self.self_type.serialize() if self.self_type is not None else None
+            ),
             "dataclass_transform_spec": (
                 self.dataclass_transform_spec.serialize()
                 if self.dataclass_transform_spec is not None
@@ -4046,7 +4048,7 @@ class DataclassTransformSpec:
         # frozen_default was added to CPythonin https://github.com/python/cpython/pull/99958 citing
         # positive discussion in typing-sig
         frozen_default: bool | None = None,
-    ):
+    ) -> None:
         self.eq_default = eq_default if eq_default is not None else True
         self.order_default = order_default if order_default is not None else False
         self.kw_only_default = kw_only_default if kw_only_default is not None else False

jaclang/vendor/mypy/options.py

@@ -321,6 +321,10 @@ class Options:
         # Use stub builtins fixtures to speed up tests
         self.use_builtins_fixtures = False
 
+        # This should only be set when running certain mypy tests.
+        # Use this sparingly to avoid tests diverging from non-test behavior.
+        self.test_env = False
+
         # -- experimental options --
         self.shadow_file: list[list[str]] | None = None
         self.show_column_numbers: bool = False