Merge remote-tracking branch 'upstream/master' into try-native-parser

Author: ilevkivskyi

mypy-requirements.txt

@@ -6,4 +6,4 @@ mypy_extensions>=1.0.0
 pathspec>=1.0.0
 tomli>=1.1.0; python_version<'3.11'
 librt>=0.9.0; platform_python_implementation != 'PyPy'
-ast-serialize>=0.2.2,<1.0.0
+ast-serialize>=0.2.3,<1.0.0

mypy/build.py

@@ -3314,7 +3314,9 @@ def semantic_analysis_pass1(self) -> None:
         #
         # TODO: This should not be considered as a semantic analysis
         #     pass -- it's an independent pass.
-        if not options.native_parser:
+        if not options.native_parser or not self.manager.fscache.exists(
+            self.xpath, real_only=True
+        ):
             analyzer = SemanticAnalyzerPreAnalysis()
             with self.wrap_context():
                 analyzer.visit_file(self.tree, self.xpath, self.id, options)

mypy/checker.py

@@ -6910,6 +6910,10 @@ def narrow_type_by_identity_equality(
                 if should_coerce_literals:
                     target_type = coerce_to_literal(target_type)
 
+                # Morally what we want to do is narrow for each branch based on:
+                # `if_type, else_type = conditional_types(expr_type, target)`
+                # What we actually do is first munge expr_type based on target_type to handle some
+                # special cased known `__eq__` implementations.
                 narrowable_expr_type, ambiguous_expr_type = partition_equality_ambiguous_types(
                     expr_type, target_type, is_identity=is_identity_comparison
                 )
@@ -6964,8 +6968,8 @@ def narrow_type_by_identity_equality(
                 continue
             union_expr_type = get_proper_type(operand_types[i])
             if not isinstance(union_expr_type, UnionType):
-                # Here we won't be able to do any positive narrowing, because we can't conclude
-                # anything from a custom __eq__ returning True.
+                # Here we don't do any positive narrowing, because we can't conclude much
+                # from a custom __eq__ returning True.
                 # But we might be able to do some negative narrowing, since we can assume
                 # a custom __eq__ is reflexive. This should only apply to custom __eq__ enums,
                 # see testNarrowingEqualityCustomEqualityEnum
@@ -7038,7 +7042,10 @@ def narrow_type_by_identity_equality(
                     if_map, else_map = conditional_types_to_typemaps(
                         operands[i], if_type, else_type
                     )
-                    or_if_maps.append(if_map)
+                    if not isinstance(get_proper_type(expr_type), AnyType):
+                        # We avoid positive narrowing for Any here, for consistency with the
+                        # non-union branch above and to preserve the gradual guarantee
+                        or_if_maps.append(if_map)
                     if is_target_for_value_narrowing(get_proper_type(target_type)):
                         or_else_maps.append(else_map)
 

mypy/nativeparse.py

@@ -715,14 +715,14 @@ def read_class_def(state: State, data: ReadBuffer) -> ClassDef:
         keywords.append((key, value))
 
     metaclass = dict(keywords).get("metaclass") if keywords else None
-    filtered_keywords = [(k, v) for k, v in keywords if k != "metaclass"] if keywords else None
 
     class_def = ClassDef(
         name,
         body,
         base_type_exprs=base_type_exprs if base_type_exprs else None,
         metaclass=metaclass,
-        keywords=filtered_keywords,
+        # Note we keep metaclass in keywords as well, to match the old parser.
+        keywords=keywords if keywords else None,
         type_args=type_params,
     )
     class_def.decorators = decorators
@@ -1329,15 +1329,16 @@ def read_expression(state: State, data: ReadBuffer) -> Expression:
         op = bool_ops[read_int(data)]
         values = read_expression_list(state, data)
         # Convert list of values to nested OpExpr nodes
-        # E.g., [a, b, c] with "and" becomes OpExpr("and", OpExpr("and", a, b), c)
+        # E.g., [a, b, c] with "and" becomes OpExpr("and", a, OpExpr("and", b, c))
+        # This matches the old parser behavior, on which we may implicitly rely.
         assert len(values) >= 2
-        result = values[0]
-        for val in values[1:]:
-            result = OpExpr(op, result, val)
-            result.line = values[0].line
-            result.column = values[0].column
-            result.end_line = val.end_line
-            result.end_column = val.end_column
+        result = last = values[-1]
+        for val in values[-2::-1]:
+            result = OpExpr(op, val, result)
+            result.line = val.line
+            result.column = val.column
+            result.end_line = last.end_line
+            result.end_column = last.end_column
         read_loc(data, result)
         expect_end_tag(data)
         return result
@@ -1375,7 +1376,7 @@ def read_expression(state: State, data: ReadBuffer) -> Expression:
                 s = StrExpr(read_str(data))
                 read_loc(data, s)
                 fitems.append(s)
-        expr = build_fstring_join(state, data, fitems)
+        expr = build_fstring_join(data, fitems)
         expect_end_tag(data)
         return expr
     elif tag == nodes.LIST_COMPREHENSION:
@@ -1576,22 +1577,17 @@ def read_expression(state: State, data: ReadBuffer) -> Expression:
 
 
 def read_fstring_items(state: State, data: ReadBuffer) -> Expression:
-    items = []
     n = read_int(data)
-    items = [read_fstring_item(state, data) for i in range(n)]
-    return build_fstring_join(state, data, items)
+    items = [read_fstring_item(state, data) for _ in range(n)]
+    return build_fstring_join(data, items)
 
 
-def build_fstring_join(state: State, data: ReadBuffer, items: list[Expression]) -> Expression:
+def build_fstring_join(data: ReadBuffer, items: list[Expression]) -> Expression:
+    items = collapse_consecutive_str_items(items)
     if len(items) == 1:
         expr = items[0]
         read_loc(data, expr)
         return expr
-    if all(isinstance(item, StrExpr) for item in items):
-        s = "".join([cast(StrExpr, item).value for item in items])
-        expr = StrExpr(s)
-        read_loc(data, expr)
-        return expr
     args = ListExpr(items)
     str_expr = StrExpr("")
     member = MemberExpr(str_expr, "join")
@@ -1603,6 +1599,22 @@ def build_fstring_join(state: State, data: ReadBuffer, items: list[Expression])
     return call
 
 
+def collapse_consecutive_str_items(items: list[Expression]) -> list[Expression]:
+    if len(items) <= 1:
+        return items
+    last = items[0]
+    new_items = [last]
+    for item in items[1:]:
+        if isinstance(last, StrExpr) and isinstance(item, StrExpr):
+            last.value += item.value
+            last.end_line = item.end_line
+            last.end_column = item.end_column
+        else:
+            new_items.append(item)
+            last = item
+    return new_items
+
+
 def read_fstring_item(state: State, data: ReadBuffer) -> Expression:
     t = read_tag(data)
     if t == LITERAL_STR:

mypy/plugins/dataclasses.py

@@ -662,7 +662,7 @@ def collect_attributes(self) -> list[DataclassAttribute] | None:
 
             # Allow bare x: Final[int] in class body, since it will be set in the generated
             # __init__() method (unless it is an InitVar), to match regular class semantics.
-            if node.is_final and not node.is_classvar and node.final_unset_in_class:
+            if node.is_final and node.final_unset_in_class:
                 if is_init_var:
                     self._api.fail("InitVar cannot be final", stmt.rvalue)
                 else:

mypyc/doc/conf.py

@@ -36,7 +36,9 @@
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions: list[str] = []
+extensions = ["sphinx.ext.intersphinx"]
+
+intersphinx_mapping = {"python": ("https://docs.python.org/3", None)}
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ["_templates"]

mypyc/doc/index.rst

@@ -33,6 +33,8 @@ generate fast code.
 
    librt
    librt_base64
+   librt_strings
+   librt_time
 
 .. toctree::
    :maxdepth: 2

mypyc/doc/librt.rst

@@ -3,7 +3,7 @@
 Librt overview
 ==============
 
-The `librt <https://pypi.org/project/librt/>`_ package defines fast
+The `librt <https://pypi.org/project/librt/>`__ package defines fast
 primitive operations that are optimized for code compiled
 using mypyc. It has carefully selected efficient alternatives for
 certain Python standard library features.
@@ -26,6 +26,10 @@ Follow submodule links in the table to a detailed description of each submodule.
      - Description
    * - :doc:`librt.base64 <librt_base64>`
      - Fast Base64 encoding and decoding
+   * - :doc:`librt.strings <librt_strings>`
+     - String and bytes utilities
+   * - :doc:`librt.time <librt_time>`
+     - Time utilities
 
 Installing librt
 ----------------