Merge branch 'master' into str-format-folding

BobTheBuidler · web-flow · commit d4a9671dcf22 · 2025-10-02T16:04:59.000-04:00
diff --git a/mypy/cache.py b/mypy/cache.py
@@ -1,65 +1,22 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, Final
+from typing import Final
 
 from mypy_extensions import u8
-
-try:
-    from native_internal import (
-        Buffer as Buffer,
-        read_bool as read_bool,
-        read_float as read_float,
-        read_int as read_int,
-        read_str as read_str,
-        read_tag as read_tag,
-        write_bool as write_bool,
-        write_float as write_float,
-        write_int as write_int,
-        write_str as write_str,
-        write_tag as write_tag,
-    )
-except ImportError:
-    # TODO: temporary, remove this after we publish mypy-native on PyPI.
-    if not TYPE_CHECKING:
-
-        class Buffer:
-            def __init__(self, source: bytes = b"") -> None:
-                raise NotImplementedError
-
-            def getvalue(self) -> bytes:
-                raise NotImplementedError
-
-        def read_int(data: Buffer) -> int:
-            raise NotImplementedError
-
-        def write_int(data: Buffer, value: int) -> None:
-            raise NotImplementedError
-
-        def read_tag(data: Buffer) -> u8:
-            raise NotImplementedError
-
-        def write_tag(data: Buffer, value: u8) -> None:
-            raise NotImplementedError
-
-        def read_str(data: Buffer) -> str:
-            raise NotImplementedError
-
-        def write_str(data: Buffer, value: str) -> None:
-            raise NotImplementedError
-
-        def read_bool(data: Buffer) -> bool:
-            raise NotImplementedError
-
-        def write_bool(data: Buffer, value: bool) -> None:
-            raise NotImplementedError
-
-        def read_float(data: Buffer) -> float:
-            raise NotImplementedError
-
-        def write_float(data: Buffer, value: float) -> None:
-            raise NotImplementedError
-
+from native_internal import (
+    Buffer as Buffer,
+    read_bool as read_bool,
+    read_float as read_float,
+    read_int as read_int,
+    read_str as read_str,
+    read_tag as read_tag,
+    write_bool as write_bool,
+    write_float as write_float,
+    write_int as write_int,
+    write_str as write_str,
+    write_tag as write_tag,
+)
 
 # Always use this type alias to refer to type tags.
 Tag = u8
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -18,6 +18,7 @@
 from mypy.checker_shared import ExpressionCheckerSharedApi
 from mypy.checkmember import analyze_member_access, has_operator
 from mypy.checkstrformat import StringFormatterChecker
+from mypy.constant_fold import constant_fold_expr
 from mypy.erasetype import erase_type, remove_instance_last_known_values, replace_meta_vars
 from mypy.errors import ErrorInfo, ErrorWatcher, report_internal_error
 from mypy.expandtype import (
@@ -656,11 +657,12 @@ def visit_call_expr_inner(self, e: CallExpr, allow_none_return: bool = False) ->
         return ret_type
 
     def check_str_format_call(self, e: CallExpr) -> None:
-        """More precise type checking for str.format() calls on literals."""
+        """More precise type checking for str.format() calls on literals and folded constants."""
         assert isinstance(e.callee, MemberExpr)
         format_value = None
-        if isinstance(e.callee.expr, StrExpr):
-            format_value = e.callee.expr.value
+        folded_callee_expr = constant_fold_expr(e.callee.expr, "<unused>")
+        if isinstance(folded_callee_expr, str):
+            format_value = folded_callee_expr
         elif self.chk.has_type(e.callee.expr):
             typ = get_proper_type(self.chk.lookup_type(e.callee.expr))
             if (
diff --git a/mypy/main.py b/mypy/main.py
@@ -1066,11 +1066,7 @@ def add_invertible_flag(
     incremental_group.add_argument(
         "--fixed-format-cache",
         action="store_true",
-        help=(
-            "Use experimental fast and compact fixed format cache"
-            if compilation_status == "yes"
-            else argparse.SUPPRESS
-        ),
+        help="Use new fast and compact fixed format cache",
     )
     incremental_group.add_argument(
         "--skip-version-check",
diff --git a/mypy/modulefinder.py b/mypy/modulefinder.py
@@ -796,7 +796,7 @@ def default_lib_path(
         custom_typeshed_dir = os.path.abspath(custom_typeshed_dir)
         typeshed_dir = os.path.join(custom_typeshed_dir, "stdlib")
         mypy_extensions_dir = os.path.join(custom_typeshed_dir, "stubs", "mypy-extensions")
-        mypy_native_dir = os.path.join(custom_typeshed_dir, "stubs", "mypy-native")
+        librt_dir = os.path.join(custom_typeshed_dir, "stubs", "librt")
         versions_file = os.path.join(typeshed_dir, "VERSIONS")
         if not os.path.isdir(typeshed_dir) or not os.path.isfile(versions_file):
             print(
@@ -812,13 +812,13 @@ def default_lib_path(
             data_dir = auto
         typeshed_dir = os.path.join(data_dir, "typeshed", "stdlib")
         mypy_extensions_dir = os.path.join(data_dir, "typeshed", "stubs", "mypy-extensions")
-        mypy_native_dir = os.path.join(data_dir, "typeshed", "stubs", "mypy-native")
+        librt_dir = os.path.join(data_dir, "typeshed", "stubs", "librt")
     path.append(typeshed_dir)
 
-    # Get mypy-extensions and mypy-native stubs from typeshed, since we treat them as
+    # Get mypy-extensions and librt stubs from typeshed, since we treat them as
     # "internal" libraries, similar to typing and typing-extensions.
     path.append(mypy_extensions_dir)
-    path.append(mypy_native_dir)
+    path.append(librt_dir)
 
     # Add fallback path that can be used if we have a broken installation.
     if sys.platform != "win32":
diff --git a/mypy/typeshed/stubs/librt/METADATA.toml b/mypy/typeshed/stubs/librt/METADATA.toml
@@ -0,0 +1 @@
+version = "0.1.*"
diff --git a/mypy/typeshed/stubs/librt/native_internal.pyi b/mypy/typeshed/stubs/librt/native_internal.pyi
diff --git a/mypy/typeshed/stubs/mypy-native/METADATA.toml b/mypy/typeshed/stubs/mypy-native/METADATA.toml
diff --git a/mypyc/irbuild/builder.py b/mypyc/irbuild/builder.py
@@ -40,7 +40,6 @@
     TypeAlias,
     TypeInfo,
     TypeParam,
-    UnaryExpr,
     Var,
 )
 from mypy.types import (
@@ -106,6 +105,7 @@
     object_rprimitive,
     str_rprimitive,
 )
+from mypyc.irbuild.constant_fold import constant_fold_expr
 from mypyc.irbuild.context import FuncInfo, ImplicitClass
 from mypyc.irbuild.ll_builder import LowLevelIRBuilder
 from mypyc.irbuild.mapper import Mapper
@@ -965,12 +965,8 @@ def maybe_spill_assignable(self, value: Value) -> Register | AssignmentTarget:
         return reg
 
     def extract_int(self, e: Expression) -> int | None:
-        if isinstance(e, IntExpr):
-            return e.value
-        elif isinstance(e, UnaryExpr) and e.op == "-" and isinstance(e.expr, IntExpr):
-            return -e.expr.value
-        else:
-            return None
+        folded = constant_fold_expr(self, e)
+        return folded if isinstance(folded, int) else None
 
     def get_sequence_type(self, expr: Expression) -> RType:
         return self.get_sequence_type_from_type(self.types[expr])
diff --git a/mypyc/irbuild/constant_fold.py b/mypyc/irbuild/constant_fold.py
@@ -10,7 +10,7 @@
 
 from __future__ import annotations
 
-from typing import Final, Union
+from typing import TYPE_CHECKING, Final, Union
 
 from mypy.constant_fold import constant_fold_binary_op, constant_fold_unary_op
 from mypy.nodes import (
@@ -27,9 +27,11 @@
     UnaryExpr,
     Var,
 )
-from mypyc.irbuild.builder import IRBuilder
 from mypyc.irbuild.util import bytes_from_str
 
+if TYPE_CHECKING:
+    from mypyc.irbuild.builder import IRBuilder
+
 # All possible result types of constant folding
 ConstantValue = Union[int, float, complex, str, bytes]
 CONST_TYPES: Final = (int, float, complex, str, bytes)
diff --git a/mypyc/irbuild/expression.py b/mypyc/irbuild/expression.py
@@ -558,7 +558,7 @@ def transform_op_expr(builder: IRBuilder, expr: OpExpr) -> Value:
     # Special case some int ops to allow borrowing operands.
     if is_int_rprimitive(ltype) and is_int_rprimitive(rtype):
         if expr.op == "//":
-            expr = try_optimize_int_floor_divide(expr)
+            expr = try_optimize_int_floor_divide(builder, expr)
         if expr.op in int_borrow_friendly_op:
             borrow_left = is_borrow_friendly_expr(builder, expr.right)
             borrow_right = True
@@ -571,11 +571,11 @@ def transform_op_expr(builder: IRBuilder, expr: OpExpr) -> Value:
     return builder.binary_op(left, right, expr.op, expr.line)
 
 
-def try_optimize_int_floor_divide(expr: OpExpr) -> OpExpr:
+def try_optimize_int_floor_divide(builder: IRBuilder, expr: OpExpr) -> OpExpr:
     """Replace // with a power of two with a right shift, if possible."""
-    if not isinstance(expr.right, IntExpr):
+    divisor = constant_fold_expr(builder, expr.right)
+    if not isinstance(divisor, int):
         return expr
-    divisor = expr.right.value
     shift = divisor.bit_length() - 1
     if 0 < shift < 28 and divisor == (1 << shift):
         return OpExpr(">>", expr.left, IntExpr(shift))
diff --git a/mypyc/irbuild/specialize.py b/mypyc/irbuild/specialize.py
@@ -19,7 +19,6 @@
 from mypy.nodes import (
     ARG_NAMED,
     ARG_POS,
-    BytesExpr,
     CallExpr,
     DictExpr,
     Expression,
@@ -78,6 +77,7 @@
     uint8_rprimitive,
 )
 from mypyc.irbuild.builder import IRBuilder
+from mypyc.irbuild.constant_fold import constant_fold_expr
 from mypyc.irbuild.for_helpers import (
     comprehension_helper,
     sequence_from_generator_preallocate_helper,
@@ -716,21 +716,18 @@ def translate_dict_setdefault(builder: IRBuilder, expr: CallExpr, callee: RefExp
 
 @specialize_function("format", str_rprimitive)
 def translate_str_format(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
-    if (
-        isinstance(callee, MemberExpr)
-        and isinstance(callee.expr, StrExpr)
-        and expr.arg_kinds.count(ARG_POS) == len(expr.arg_kinds)
-    ):
-        format_str = callee.expr.value
-        tokens = tokenizer_format_call(format_str)
-        if tokens is None:
-            return None
-        literals, format_ops = tokens
-        # Convert variables to strings
-        substitutions = convert_format_expr_to_str(builder, format_ops, expr.args, expr.line)
-        if substitutions is None:
-            return None
-        return join_formatted_strings(builder, literals, substitutions, expr.line)
+    if isinstance(callee, MemberExpr):
+        folded_callee = constant_fold_expr(builder, callee.expr)
+        if isinstance(folded_callee, str) and expr.arg_kinds.count(ARG_POS) == len(expr.arg_kinds):
+            tokens = tokenizer_format_call(folded_callee)
+            if tokens is None:
+                return None
+            literals, format_ops = tokens
+            # Convert variables to strings
+            substitutions = convert_format_expr_to_str(builder, format_ops, expr.args, expr.line)
+            if substitutions is None:
+                return None
+            return join_formatted_strings(builder, literals, substitutions, expr.line)
     return None
 
 
@@ -1059,9 +1056,9 @@ def translate_float(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Valu
 def translate_ord(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     if len(expr.args) != 1 or expr.arg_kinds[0] != ARG_POS:
         return None
-    arg = expr.args[0]
-    if isinstance(arg, (StrExpr, BytesExpr)) and len(arg.value) == 1:
-        return Integer(ord(arg.value))
+    arg = constant_fold_expr(builder, expr.args[0])
+    if isinstance(arg, (str, bytes)) and len(arg) == 1:
+        return Integer(ord(arg))
     return None
 
 
diff --git a/pyproject.toml b/pyproject.toml
@@ -54,6 +54,7 @@ dependencies = [
   "mypy_extensions>=1.0.0",
   "pathspec>=0.9.0",
   "tomli>=1.1.0; python_version<'3.11'",
+  "librt>=0.1.0",
 ]
 dynamic = ["version"]
 
