Use --no-implicit-optional by default (#13401)

Fixes #9091

This brings us in line with the PEP 484 updates in 2018

Author: hauntsaninja

docs/source/command_line.rst

@@ -390,29 +390,23 @@ None and Optional handling
 The following flags adjust how mypy handles values of type ``None``.
 For more details, see :ref:`no_strict_optional`.
 
-.. _no-implicit-optional:
+.. _implicit-optional:
 
-.. option:: --no-implicit-optional
+.. option:: --implicit-optional
 
-    This flag causes mypy to stop treating arguments with a ``None``
+    This flag causes mypy to treat arguments with a ``None``
     default value as having an implicit :py:data:`~typing.Optional` type.
 
-    For example, by default mypy will assume that the ``x`` parameter
-    is of type ``Optional[int]`` in the code snippet below since
-    the default parameter is ``None``:
+    For example, if this flag is set, mypy would assume that the ``x``
+    parameter is actually of type ``Optional[int]`` in the code snippet below
+    since the default parameter is ``None``:
 
     .. code-block:: python
 
         def foo(x: int = None) -> None:
             print(x)
 
-    If this flag is set, the above snippet will no longer type check:
-    we must now explicitly indicate that the type is ``Optional[int]``:
-
-    .. code-block:: python
-
-        def foo(x: Optional[int] = None) -> None:
-            print(x)
+    **Note:** This was disabled by default starting in mypy 0.980.
 
 .. option:: --no-strict-optional
 

docs/source/config_file.rst

@@ -503,13 +503,15 @@ None and Optional handling
 For more information, see the :ref:`None and Optional handling <none-and-optional-handling>`
 section of the command line docs.
 
-.. confval:: no_implicit_optional
+.. confval:: implicit_optional
 
     :type: boolean
     :default: False
 
-    Changes the treatment of arguments with a default value of ``None`` by not implicitly
-    making their type :py:data:`~typing.Optional`.
+    Causes mypy to treat arguments with a ``None``
+    default value as having an implicit :py:data:`~typing.Optional` type.
+
+    **Note:** This was True by default in mypy versions 0.980 and earlier.
 
 .. confval:: strict_optional
 

docs/source/kinds_of_types.rst

@@ -388,12 +388,8 @@ case you should add an explicit ``Optional[...]`` annotation (or type comment).
 .. note::
 
     ``Optional[...]`` *does not* mean a function argument with a default value.
-    However, if the default value of an argument is ``None``, you can use
-    an optional type for the argument, but it's not enforced by default.
-    You can use the :option:`--no-implicit-optional <mypy --no-implicit-optional>` command-line option to stop
-    treating arguments with a ``None`` default value as having an implicit
-    ``Optional[...]`` type. It's possible that this will become the default
-    behavior in the future.
+    It simply means that ``None`` is a valid value for the argument. This is
+    a common confusion because ``None`` is a common default value for arguments.
 
 .. _alternative_union_syntax:
 

mypy/fastparse.py

@@ -1003,7 +1003,7 @@ def do_func_def(
         return retval
 
     def set_type_optional(self, type: Type | None, initializer: Expression | None) -> None:
-        if self.options.no_implicit_optional:
+        if not self.options.implicit_optional:
             return
         # Indicate that type should be wrapped in an Optional if arg is initialized to None.
         optional = isinstance(initializer, NameExpr) and initializer.name == "None"

mypy/main.py

@@ -720,10 +720,9 @@ def add_invertible_flag(
         "https://mypy.readthedocs.io/en/stable/kinds_of_types.html#no-strict-optional",
     )
     add_invertible_flag(
-        "--no-implicit-optional",
+        "--implicit-optional",
         default=False,
-        strict_flag=True,
-        help="Don't assume arguments with default values of None are Optional",
+        help="Assume arguments with default values of None are Optional",
         group=none_group,
     )
     none_group.add_argument("--strict-optional", action="store_true", help=argparse.SUPPRESS)

mypy/options.py

@@ -39,14 +39,14 @@ class BuildType:
     "disallow_untyped_defs",
     "enable_error_code",
     "enabled_error_codes",
-    "follow_imports",
     "follow_imports_for_stubs",
+    "follow_imports",
     "ignore_errors",
     "ignore_missing_imports",
+    "implicit_optional",
     "implicit_reexport",
     "local_partial_types",
     "mypyc",
-    "no_implicit_optional",
     "strict_concatenate",
     "strict_equality",
     "strict_optional",
@@ -162,8 +162,8 @@ def __init__(self) -> None:
         self.color_output = True
         self.error_summary = True
 
-        # Don't assume arguments with default values of None are Optional
-        self.no_implicit_optional = False
+        # Assume arguments with default values of None are Optional
+        self.implicit_optional = False
 
         # Don't re-export names unless they are imported with `from ... as ...`
         self.implicit_reexport = True

test-data/unit/check-classes.test

@@ -2979,8 +2979,9 @@ class B: pass
 
 
 [case testConstructInstanceWith__new__]
+from typing import Optional
 class C:
-    def __new__(cls, foo: int = None) -> 'C':
+    def __new__(cls, foo: Optional[int] = None) -> 'C':
         obj = object.__new__(cls)
         return obj
 

test-data/unit/check-fastparse.test

@@ -106,6 +106,7 @@ class C:
 [builtins fixtures/property.pyi]
 
 [case testFastParsePerArgumentAnnotations]
+# flags: --implicit-optional
 
 class A: pass
 class B: pass
@@ -130,6 +131,7 @@ def f(a,        # type: A
 [out]
 
 [case testFastParsePerArgumentAnnotationsWithReturn]
+# flags: --implicit-optional
 
 class A: pass
 class B: pass

test-data/unit/check-flags.test

@@ -843,6 +843,7 @@ standard.f(None)
 [file mypy.ini]
 \[mypy]
 strict_optional = False
+implicit_optional = true
 \[mypy-optional]
 strict_optional = True
 
@@ -862,6 +863,7 @@ standard.f(None)
 [file pyproject.toml]
 \[tool.mypy]
 strict_optional = false
+implicit_optional = true
 \[[tool.mypy.overrides]]
 module = 'optional'
 strict_optional = true

test-data/unit/check-functions.test

@@ -465,6 +465,7 @@ if int():
 
 
 [case testCallingFunctionsWithDefaultArgumentValues]
+# flags: --implicit-optional --no-strict-optional
 
 a, b = None, None # type: (A, B)
 if int():