Merge branch 'master' into config-extend

Author: hasier

docs/source/command_line.rst

@@ -593,12 +593,58 @@ of the above sections.
     This flag causes mypy to suppress errors caused by not being able to fully
     infer the types of global and class variables.
 
-.. option:: --allow-redefinition
+.. option:: --allow-redefinition-new
 
     By default, mypy won't allow a variable to be redefined with an
-    unrelated type. This flag enables redefinition of a variable with an
+    unrelated type. This *experimental* flag enables the redefinition of
+    unannotated variables with an arbitrary type. You will also need to enable
+    :option:`--local-partial-types <mypy --local-partial-types>`.
+    Example:
+
+    .. code-block:: python
+
+        def maybe_convert(n: int, b: bool) -> int | str:
+            if b:
+                x = str(n)  # Assign "str"
+            else:
+                x = n       # Assign "int"
+            # Type of "x" is "int | str" here.
+            return x
+
+    Without the new flag, mypy only supports inferring optional types
+    (``X | None``) from multiple assignments. With this option enabled,
+    mypy can infer arbitrary union types.
+
+    This also enables an unannotated variable to have different types in different
+    code locations:
+
+    .. code-block:: python
+
+        if check():
+            for x in range(n):
+                # Type of "x" is "int" here.
+                ...
+        else:
+            for x in ['a', 'b']:
+                # Type of "x" is "str" here.
+                ...
+
+    Note: We are planning to turn this flag on by default in a future mypy
+    release, along with :option:`--local-partial-types <mypy --local-partial-types>`.
+    The feature is still experimental, and the semantics may still change.
+
+.. option:: --allow-redefinition
+
+    This is an older variant of
+    :option:`--allow-redefinition-new <mypy --allow-redefinition-new>`.
+    This flag enables redefinition of a variable with an
     arbitrary type *in some contexts*: only redefinitions within the
     same block and nesting depth as the original definition are allowed.
+
+    We have no plans to remove this flag, but we expect that
+    :option:`--allow-redefinition-new <mypy --allow-redefinition-new>`
+    will replace this flag for new use cases eventually.
+
     Example where this can be useful:
 
     .. code-block:: python

docs/source/config_file.rst

@@ -713,6 +713,44 @@ section of the command line docs.
     Causes mypy to suppress errors caused by not being able to fully
     infer the types of global and class variables.
 
+.. confval:: allow_redefinition_new
+
+    :type: boolean
+    :default: False
+
+    By default, mypy won't allow a variable to be redefined with an
+    unrelated type. This *experimental* flag enables the redefinition of
+    unannotated variables with an arbitrary type. You will also need to enable
+    :confval:`local_partial_types`.
+    Example:
+
+    .. code-block:: python
+
+        def maybe_convert(n: int, b: bool) -> int | str:
+            if b:
+                x = str(n)  # Assign "str"
+            else:
+                x = n       # Assign "int"
+            # Type of "x" is "int | str" here.
+            return x
+
+    This also enables an unannotated variable to have different types in different
+    code locations:
+
+    .. code-block:: python
+
+        if check():
+            for x in range(n):
+                # Type of "x" is "int" here.
+                ...
+        else:
+            for x in ['a', 'b']:
+                # Type of "x" is "str" here.
+                ...
+
+    Note: We are planning to turn this flag on by default in a future mypy
+    release, along with :confval:`local_partial_types`.
+
 .. confval:: allow_redefinition
 
     :type: boolean
@@ -746,6 +784,7 @@ section of the command line docs.
 
     Disallows inferring variable type for ``None`` from two assignments in different scopes.
     This is always implicitly enabled when using the :ref:`mypy daemon <mypy_daemon>`.
+    This will be enabled by default in a future mypy release.
 
 .. confval:: disable_error_code
 

mypy/join.py

@@ -635,6 +635,8 @@ def default(self, typ: Type) -> ProperType:
         typ = get_proper_type(typ)
         if isinstance(typ, Instance):
             return object_from_instance(typ)
+        elif isinstance(typ, TypeType):
+            return self.default(typ.item)
         elif isinstance(typ, UnboundType):
             return AnyType(TypeOfAny.special_form)
         elif isinstance(typ, TupleType):

mypy/plugins/default.py

@@ -316,7 +316,7 @@ def typed_dict_pop_callback(ctx: MethodContext) -> Type:
 
         value_types = []
         for key in keys:
-            if key in ctx.type.required_keys:
+            if key in ctx.type.required_keys or key in ctx.type.readonly_keys:
                 ctx.api.msg.typeddict_key_cannot_be_deleted(ctx.type, key, key_expr)
 
             value_type = ctx.type.items.get(key)

mypy/test/testtypes.py

@@ -1064,6 +1064,10 @@ def test_variadic_tuple_joins(self) -> None:
             self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a])), self.fx.a),
         )
 
+    def test_join_type_type_type_var(self) -> None:
+        self.assert_join(self.fx.type_a, self.fx.t, self.fx.o)
+        self.assert_join(self.fx.t, self.fx.type_a, self.fx.o)
+
     # There are additional test cases in check-inference.test.
 
     # TODO: Function types + varargs and default args.

mypy/version.py

@@ -8,7 +8,7 @@
 # - Release versions have the form "1.2.3".
 # - Dev versions have the form "1.2.3+dev" (PLUS sign to conform to PEP 440).
 # - Before 1.0 we had the form "0.NNN".
-__version__ = "1.16.0+dev"
+__version__ = "1.17.0+dev"
 base_version = __version__
 
 mypy_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))

mypyc/doc/native_classes.rst

@@ -48,11 +48,13 @@ can be assigned to (similar to using ``__slots__``)::
 Inheritance
 -----------
 
-Only single inheritance is supported (except for :ref:`traits
-<trait-types>`). Most non-native classes can't be used as base
-classes.
+Only single inheritance is supported from native classes (except for
+:ref:`traits <trait-types>`). Most non-native extension classes can't
+be used as base classes, but regular Python classes can be used as
+base classes unless they use unsupported metaclasses (see below for
+more about this).
 
-These non-native classes can be used as base classes of native
+These non-native extension classes can be used as base classes of native
 classes:
 
 * ``object``
@@ -63,8 +65,6 @@ classes:
 * ``IndexError``
 * ``LookupError``
 * ``UserWarning``
-* ``typing.NamedTuple``
-* ``enum.Enum``
 
 By default, a non-native class can't inherit a native class, and you
 can't inherit from a native class outside the compilation unit that
@@ -89,6 +89,15 @@ You need to install ``mypy-extensions`` to use ``@mypyc_attr``:
 
     pip install --upgrade mypy-extensions
 
+Additionally, mypyc recognizes these base classes as special, and
+understands how they alter the behavior of classes (including native
+classes) that subclass them:
+
+* ``typing.NamedTuple``
+* ``typing.Generic``
+* ``typing.Protocol``
+* ``enum.Enum``
+
 Class variables
 ---------------
 
@@ -145,7 +154,8 @@ behavior is too dynamic. You can use these metaclasses, however:
 .. note::
 
    If a class definition uses an unsupported metaclass, *mypyc
-   compiles the class into a regular Python class*.
+   compiles the class into a regular Python class* (non-native
+   class).
 
 Class decorators
 ----------------
@@ -165,7 +175,63 @@ efficient as pure native classes.
 .. note::
 
    If a class definition uses an unsupported class decorator, *mypyc
-   compiles the class into a regular Python class*.
+   compiles the class into a regular Python class* (non-native class).
+
+Defining non-native classes
+---------------------------
+
+You can use the ``@mypy_extensions.mypyc_attr(...)`` class decorator
+with an argument ``native_class=False`` to explicitly define normal
+Python classes (non-native classes)::
+
+    from mypy_extensions import mypyc_attr
+
+    @mypyc_attr(native_class=False)
+    class NonNative:
+        def __init__(self) -> None:
+            self.attr = 1
+
+    setattr(NonNative, "extra", 1)  # Ok
+
+This only has an effect in classes compiled using mypyc. Non-native
+classes are significantly less efficient than native classes, but they
+are sometimes necessary to work around the limitations of native classes.
+
+Non-native classes can use arbitrary metaclasses and class decorators,
+and they support flexible multiple inheritance.  Mypyc will still
+generate a compile-time error if you try to assign to a method, or an
+attribute that is not defined in a class body, since these are static
+type errors detected by mypy::
+
+    o = NonNative()
+    o.extra = "x"  # Static type error: "extra" not defined
+
+However, these operations still work at runtime, including in modules
+that are not compiled using mypyc. You can also use ``setattr`` and
+``getattr`` for dynamic access of arbitrary attributes. Expressions
+with an ``Any`` type are also not type checked statically, allowing
+access to arbitrary attributes::
+
+    a: Any = o
+    a.extra = "x"  # Ok
+
+    setattr(o, "extra", "y")  # Also ok
+
+Implicit non-native classes
+---------------------------
+
+If a compiled class uses an unsupported metaclass or an unsupported
+class decorator, it will implicitly be a non-native class, as
+discussed above. You can still use ``@mypyc_attr(native_class=False)``
+to explicitly mark it as a non-native class.
+
+Explicit native classes
+-----------------------
+
+You can use ``@mypyc_attr(native_class=True)`` to explicitly declare a
+class as a native class. It will be a compile-time error if mypyc
+can't compile the class as a native class. You can use this to avoid
+accidentally defining implicit non-native classes.
 
 Deleting attributes
 -------------------

test-data/unit/check-typeddict.test

@@ -3760,20 +3760,24 @@ del x["optional_key"]  # E: Key "optional_key" of TypedDict "TP" cannot be delet
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictReadOnlyMutateMethods]
-from typing import ReadOnly, TypedDict
+from typing import ReadOnly, NotRequired, TypedDict
 
 class TP(TypedDict):
     key: ReadOnly[str]
+    optional_key: ReadOnly[NotRequired[str]]
     other: ReadOnly[int]
     mutable: bool
 
 x: TP
 reveal_type(x.pop("key"))  # N: Revealed type is "builtins.str" \
                            # E: Key "key" of TypedDict "TP" cannot be deleted
+reveal_type(x.pop("optional_key"))  # N: Revealed type is "builtins.str" \
+                                    # E: Key "optional_key" of TypedDict "TP" cannot be deleted
 
 
 x.update({"key": "abc", "other": 1, "mutable": True})  # E: ReadOnly TypedDict keys ("key", "other") TypedDict are mutated
 x.setdefault("key", "abc")  # E: ReadOnly TypedDict key "key" TypedDict is mutated
+x.setdefault("optional_key", "foo")  # E: ReadOnly TypedDict key "optional_key" TypedDict is mutated
 x.setdefault("other", 1)  # E: ReadOnly TypedDict key "other" TypedDict is mutated
 x.setdefault("mutable", False)  # ok
 [builtins fixtures/dict.pyi]