Merge branch 'master' into dict-literals

Author: BobTheBuidler

CHANGELOG.md

@@ -11,6 +11,27 @@ Support for this will be dropped in the first half of 2026!
 
 Contributed by Marc Mueller (PR [20156](https://github.com/python/mypy/pull/20156)).
 
+### Mypyc Accelerated Mypy Wheels for ARM Windows and Free Threading
+
+For best performance, mypy can be compiled to C extension modules using mypyc. This makes
+mypy 3-5x faster than when interpreted with pure Python. We now build and upload mypyc
+accelerated mypy wheels for `win_arm64` and `cp314t-...` to PyPI, making it easy for Windows
+users on ARM and those using the free theading builds for Python 3.14 to realise this speedup
+-- just `pip install` the latest mypy.
+
+Contributed by Marc Mueller
+(PR [mypy_mypyc-wheels#106](https://github.com/mypyc/mypy_mypyc-wheels/pull/106),
+PR [mypy_mypyc-wheels#110](https://github.com/mypyc/mypy_mypyc-wheels/pull/110)).
+
+### Removed flags `--force-uppercase-builtins` and `--force-union-syntax`
+
+The `--force-uppercase-builtins` flag was deprecated and has been a no-op since mypy 1.17.0.
+Since mypy has dropped support for Python 3.9, the `--force-union-syntax` flag is no longer
+necessary.
+
+Contributed by Marc Mueller (PR [20410](https://github.com/python/mypy/pull/20410))
+and (PR [20405](https://github.com/python/mypy/pull/20405)).
+
 ## Mypy 1.19
 
 We’ve just uploaded mypy 1.19.0 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)).
@@ -216,6 +237,17 @@ Related PRs:
 
 Please see [git log](https://github.com/python/typeshed/commits/main?after=ebce8d766b41fbf4d83cf47c1297563a9508ff60+0&branch=main&path=stdlib) for full list of standard library typeshed stub changes.
 
+### Mypy 1.19.1
+
+- Fix noncommutative joins with bounded TypeVars (Shantanu, PR [20345](https://github.com/python/mypy/pull/20345))
+- Respect output format for cached runs by serializing raw errors in cache metas (Ivan Levkivskyi, PR [20372](https://github.com/python/mypy/pull/20372))
+- Allow `types.NoneType` in match cases (A5rocks, PR [20383](https://github.com/python/mypy/pull/20383))
+- Fix mypyc generator regression with empty tuple (BobTheBuidler, PR [20371](https://github.com/python/mypy/pull/20371))
+- Fix crash involving Unpack-ed TypeVarTuple (Shantanu, PR [20323](https://github.com/python/mypy/pull/20323))
+- Fix crash on star import of redefinition (Ivan Levkivskyi, PR [20333](https://github.com/python/mypy/pull/20333))
+- Fix crash on typevar with forward ref used in other module (Ivan Levkivskyi, PR [20334](https://github.com/python/mypy/pull/20334))
+- Fail with an explicit error on PyPy (Ivan Levkivskyi, PR [20389](https://github.com/python/mypy/pull/20389))
+
 ### Acknowledgements
 
 Thanks to all mypy contributors who contributed to this release:
@@ -251,7 +283,7 @@ Thanks to all mypy contributors who contributed to this release:
 
 I’d also like to thank my employer, Dropbox, for supporting mypy development.
 
-## Mypy 1.18.1
+## Mypy 1.18
 
 We’ve just uploaded mypy 1.18.1 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)).
 Mypy is a static type checker for Python. This release includes new features, performance

docs/source/additional_features.rst

@@ -135,7 +135,7 @@ Type annotations can be added as follows:
 
 .. code-block:: python
 
-    import attr
+    import attrs
 
     @attrs.define
     class A:

docs/source/command_line.rst

@@ -958,12 +958,6 @@ in error messages.
     useful or they may be overly noisy. If ``N`` is negative, there is
     no limit. The default limit is -1.
 
-.. option:: --force-union-syntax
-
-    Always use ``Union[]`` and ``Optional[]`` for union types
-    in error messages (instead of the ``|`` operator),
-    even on Python 3.10+.
-
 
 .. _incremental:
 

docs/source/config_file.rst

@@ -930,15 +930,6 @@ These options may only be set in the global section (``[mypy]``).
 
     Show absolute paths to files.
 
-.. confval:: force_union_syntax
-
-    :type: boolean
-    :default: False
-
-    Always use ``Union[]`` and ``Optional[]`` for union types
-    in error messages (instead of the ``|`` operator),
-    even on Python 3.10+.
-
 Incremental mode
 ****************
 

mypy/checker.py

@@ -5968,7 +5968,7 @@ def _make_fake_typeinfo_and_full_name(
             errors.append((pretty_names_list, "would have incompatible method signatures"))
             return None
 
-        curr_module.names[full_name] = SymbolTableNode(GDEF, info)
+        curr_module.names[full_name] = SymbolTableNode(GDEF, info, False, module_hidden=True)
         return Instance(info, [], extra_attrs=instances[0].extra_attrs or instances[1].extra_attrs)
 
     def intersect_instance_callable(self, typ: Instance, callable_type: CallableType) -> Instance:
@@ -6654,6 +6654,28 @@ def equality_type_narrowing_helper(
         narrowable_operand_index_to_hash: dict[int, tuple[Key, ...]],
     ) -> tuple[TypeMap, TypeMap]:
         """Calculate type maps for '==', '!=', 'is' or 'is not' expression."""
+        # If we haven't been able to narrow types yet, we might be dealing with a
+        # explicit type(x) == some_type check
+        if_map, else_map = self.narrow_type_by_equality(
+            operator,
+            operands,
+            operand_types,
+            expr_indices,
+            narrowable_operand_index_to_hash.keys(),
+        )
+        if if_map == {} and else_map == {} and node is not None:
+            if_map, else_map = self.find_type_equals_check(node, expr_indices)
+        return if_map, else_map
+
+    def narrow_type_by_equality(
+        self,
+        operator: str,
+        operands: list[Expression],
+        operand_types: list[Type],
+        expr_indices: list[int],
+        narrowable_indices: AbstractSet[int],
+    ) -> tuple[TypeMap, TypeMap]:
+        """Calculate type maps for '==', '!=', 'is' or 'is not' expression, ignoring `type(x)` checks."""
         # is_valid_target:
         #   Controls which types we're allowed to narrow exprs to. Note that
         #   we cannot use 'is_literal_type_like' in both cases since doing
@@ -6699,20 +6721,15 @@ def has_no_custom_eq_checks(t: Type) -> bool:
                 operands,
                 operand_types,
                 expr_indices,
-                narrowable_operand_index_to_hash.keys(),
+                narrowable_indices,
                 is_valid_target,
                 coerce_only_in_literal_context,
             )
 
         if if_map == {} and else_map == {}:
             if_map, else_map = self.refine_away_none_in_comparison(
-                operands, operand_types, expr_indices, narrowable_operand_index_to_hash.keys()
+                operands, operand_types, expr_indices, narrowable_indices
             )
-
-        # If we haven't been able to narrow types yet, we might be dealing with a
-        # explicit type(x) == some_type check
-        if if_map == {} and else_map == {}:
-            if_map, else_map = self.find_type_equals_check(node, expr_indices)
         return if_map, else_map
 
     def propagate_up_typemap_info(self, new_types: TypeMap) -> TypeMap:
@@ -6947,6 +6964,11 @@ def should_coerce_inner(typ: Type) -> bool:
         for i in chain_indices:
             expr_type = operand_types[i]
             if should_coerce:
+                # TODO: doing this prevents narrowing a single-member Enum to literal
+                # of its member, because we expand it here and then refuse to add equal
+                # types to typemaps. As a result, `x: Foo; x == Foo.A` does not narrow
+                # `x` to `Literal[Foo.A]` iff `Foo` has exactly one member.
+                # See testMatchEnumSingleChoice
                 expr_type = coerce_to_literal(expr_type)
             if not is_valid_target(get_proper_type(expr_type)):
                 continue

mypy/checker_shared.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from collections.abc import Iterator, Sequence
+from collections.abc import Iterator, Sequence, Set as AbstractSet
 from contextlib import contextmanager
 from typing import NamedTuple, overload
 
@@ -245,6 +245,17 @@ def conditional_types_with_intersection(
     ) -> tuple[Type | None, Type | None]:
         raise NotImplementedError
 
+    @abstractmethod
+    def narrow_type_by_equality(
+        self,
+        operator: str,
+        operands: list[Expression],
+        operand_types: list[Type],
+        expr_indices: list[int],
+        narrowable_indices: AbstractSet[int],
+    ) -> tuple[dict[Expression, Type] | None, dict[Expression, Type] | None]:
+        raise NotImplementedError
+
     @abstractmethod
     def check_deprecated(self, node: Node | None, context: Context) -> None:
         raise NotImplementedError