Merge branch 'master' into newfeature

Author: LeoLomardo

mypy-requirements.txt

@@ -4,4 +4,4 @@ typing_extensions>=4.6.0
 mypy_extensions>=1.0.0
 pathspec>=0.9.0
 tomli>=1.1.0; python_version<'3.11'
-librt>=0.6.2
+librt>=0.6.2; platform_python_implementation != 'PyPy'

mypy/checkpattern.py

@@ -46,6 +46,7 @@
     Type,
     TypedDictType,
     TypeOfAny,
+    TypeType,
     TypeVarTupleType,
     TypeVarType,
     UninhabitedType,
@@ -556,6 +557,8 @@ def visit_class_pattern(self, o: ClassPattern) -> PatternType:
             fallback = self.chk.named_type("builtins.function")
             any_type = AnyType(TypeOfAny.unannotated)
             typ = callable_with_ellipsis(any_type, ret_type=any_type, fallback=fallback)
+        elif isinstance(p_typ, TypeType) and isinstance(p_typ.item, NoneType):
+            typ = p_typ.item
         elif not isinstance(p_typ, AnyType):
             self.msg.fail(
                 message_registry.CLASS_PATTERN_TYPE_REQUIRED.format(

mypy/main.py

@@ -815,6 +815,10 @@ def add_invertible_flag(
     add_invertible_flag(
         "--force-union-syntax", default=False, help=argparse.SUPPRESS, group=none_group
     )
+    # For internal use only! Will be removed once Mypy drops support for Python 3.9.
+    add_invertible_flag(
+        "--overwrite-union-syntax", default=False, help=argparse.SUPPRESS, group=none_group
+    )
 
     lint_group = parser.add_argument_group(
         title="Configuring warnings",

mypy/options.py

@@ -413,6 +413,8 @@ def __init__(self) -> None:
         # Deprecated, Mypy only supports Python 3.9+
         self.force_uppercase_builtins = False
         self.force_union_syntax = False
+        # Mypy internal use only! Set during test run.
+        self.overwrite_union_syntax = False
 
         # Sets custom output format
         self.output: str | None = None
@@ -434,7 +436,7 @@ def use_lowercase_names(self) -> bool:
     def use_or_syntax(self) -> bool:
         if self.python_version >= (3, 10):
             return not self.force_union_syntax
-        return False
+        return self.overwrite_union_syntax
 
     def use_star_unpack(self) -> bool:
         return self.python_version >= (3, 11)

mypy/test/testcmdline.py

@@ -60,14 +60,13 @@ def test_python_cmdline(testcase: DataDrivenTestCase, step: int) -> None:
     args = parse_args(testcase.input[0])
     custom_cwd = parse_cwd(testcase.input[1]) if len(testcase.input) > 1 else None
     args.append("--show-traceback")
+    args.append("--overwrite-union-syntax")
     if "--error-summary" not in args:
         args.append("--no-error-summary")
     if "--show-error-codes" not in args:
         args.append("--hide-error-codes")
     if "--disallow-empty-bodies" not in args:
         args.append("--allow-empty-bodies")
-    if "--no-force-union-syntax" not in args:
-        args.append("--force-union-syntax")
     # Type check the program.
     fixed = [python3_path, "-m", "mypy"]
     env = os.environ.copy()

mypy/test/testpythoneval.py

@@ -52,6 +52,7 @@ def test_python_evaluation(testcase: DataDrivenTestCase, cache_dir: str) -> None
         "--no-error-summary",
         "--hide-error-codes",
         "--allow-empty-bodies",
+        "--overwrite-union-syntax",
         "--test-env",  # Speeds up some checks
     ]
     interpreter = python3_path
@@ -71,9 +72,6 @@ def test_python_evaluation(testcase: DataDrivenTestCase, cache_dir: str) -> None
                     return
         mypy_cmdline.extend(additional_flags)
 
-    if "--no-force-union-syntax" not in mypy_cmdline:
-        mypy_cmdline.append("--force-union-syntax")
-
     # Write the program to a file.
     program = "_" + testcase.name + ".py"
     program_path = os.path.join(test_temp_dir, program)

mypy/types.py

@@ -3736,6 +3736,7 @@ class TypeStrVisitor(SyntheticTypeVisitor[str]):
     Notes:
      - Represent unbound types as Foo? or Foo?[...].
      - Represent the NoneType type as None.
+     - Represent Union[x, y] as x | y
     """
 
     def __init__(self, id_mapper: IdMapper | None = None, *, options: Options) -> None:

mypyc/ir/deps.py

@@ -50,3 +50,4 @@ def get_header(self) -> str:
 LIBRT_BASE64: Final = Capsule("librt.base64")
 
 BYTES_EXTRA_OPS: Final = SourceDep("bytes_extra_ops.c")
+BYTES_WRITER_EXTRA_OPS: Final = SourceDep("byteswriter_extra_ops.c")

mypyc/irbuild/builder.py

@@ -990,8 +990,10 @@ def get_sequence_type_from_type(self, target_type: Type) -> RType:
         elif isinstance(target_type, TypeVarLikeType):
             return self.get_sequence_type_from_type(target_type.upper_bound)
         elif isinstance(target_type, TupleType):
+            items = target_type.items
+            assert items, "This function does not support empty tuples"
             # Tuple might have elements of different types.
-            rtypes = {self.mapper.type_to_rtype(item) for item in target_type.items}
+            rtypes = set(map(self.mapper.type_to_rtype, items))
             if len(rtypes) == 1:
                 return rtypes.pop()
             else:

mypyc/irbuild/for_helpers.py

@@ -8,7 +8,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import ClassVar
+from typing import ClassVar, cast
 
 from mypy.nodes import (
     ARG_POS,
@@ -242,25 +242,45 @@ def sequence_from_generator_preallocate_helper(
         rtype = builder.node_type(sequence_expr)
         if not (is_sequence_rprimitive(rtype) or isinstance(rtype, RTuple)):
             return None
-        sequence = builder.accept(sequence_expr)
-        length = get_expr_length_value(builder, sequence_expr, sequence, line, use_pyssize_t=True)
+
         if isinstance(rtype, RTuple):
             # If input is RTuple, box it to tuple_rprimitive for generic iteration
             # TODO: this can be optimized a bit better with an unrolled ForRTuple helper
             proper_type = get_proper_type(builder.types[sequence_expr])
             assert isinstance(proper_type, TupleType), proper_type
 
-            get_item_ops = [
-                (
-                    LoadLiteral(typ.value, object_rprimitive)
-                    if isinstance(typ, LiteralType)
-                    else TupleGet(sequence, i, line)
-                )
-                for i, typ in enumerate(get_proper_types(proper_type.items))
-            ]
+            # the for_loop_helper_with_index crashes for empty tuples, bail out
+            if not proper_type.items:
+                return None
+
+            proper_types = get_proper_types(proper_type.items)
+
+            get_item_ops: list[LoadLiteral | TupleGet]
+            if all(isinstance(typ, LiteralType) for typ in proper_types):
+                get_item_ops = [
+                    LoadLiteral(cast(LiteralType, typ).value, object_rprimitive)
+                    for typ in proper_types
+                ]
+
+            else:
+                sequence = builder.accept(sequence_expr)
+                get_item_ops = [
+                    (
+                        LoadLiteral(typ.value, object_rprimitive)
+                        if isinstance(typ, LiteralType)
+                        else TupleGet(sequence, i, line)
+                    )
+                    for i, typ in enumerate(proper_types)
+                ]
+
             items = list(map(builder.add, get_item_ops))
             sequence = builder.new_tuple(items, line)
 
+        else:
+            sequence = builder.accept(sequence_expr)
+
+        length = get_expr_length_value(builder, sequence_expr, sequence, line, use_pyssize_t=True)
+
         target_op = empty_op_llbuilder(length, line)
 
         def set_item(item_index: Value) -> None: