Internally rename allow_redefiniton to allow_redefinition_old (#20764)

Ref #20726

This also make `--allow-redefinition` simply an alias to
`--allow-redefinition-old`. In v2.0 we can simply flip this to point to
`--allow-redefinition-new`. IMO this way there is less confusion between
publicly visible flags and internal mypy options.

Also I no longer call `--allow-redefinition-new` experimental, and
clarify timeline to mention v2.0 release.

I also use this opportunity to use more consistent variable names in
config parser (`key` vs `options_key`).

Author: ilevkivskyi

docs/source/command_line.rst

@@ -598,8 +598,8 @@ of the above sections.
 .. option:: --allow-redefinition-new
 
     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
+    unrelated type. This 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:
 
@@ -637,6 +637,13 @@ of the above sections.
 
 .. option:: --allow-redefinition
 
+    This is an alias to :option:`--allow-redefinition-old <mypy --allow-redefinition-old>`.
+    In mypy v2.0 this will point to
+    :option:`--allow-redefinition-new <mypy --allow-redefinition-new>`, and will
+    eventually became the default.
+
+.. option:: --allow-redefinition-old
+
     This is an older variant of
     :option:`--allow-redefinition-new <mypy --allow-redefinition-new>`.
     This flag enables redefinition of a variable with an
@@ -689,7 +696,7 @@ of the above sections.
         reveal_type(Foo().bar)  # 'int | None' without --local-partial-types
 
     Note: this option is always implicitly enabled in mypy daemon and will become
-    enabled by default for mypy in a future release.
+    enabled by default in mypy v2.0 release.
 
 .. option:: --no-implicit-reexport
 

docs/source/config_file.rst

@@ -719,8 +719,8 @@ section of the command line docs.
     :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
+    unrelated type. This flag enables the redefinition of unannotated
+    variables with an arbitrary type. You will also need to enable
     :confval:`local_partial_types`.
     Example:
 
@@ -751,7 +751,7 @@ section of the command line docs.
     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
+.. confval:: allow_redefinition_old
 
     :type: boolean
     :default: False
@@ -777,14 +777,22 @@ section of the command line docs.
            items = "100"  # valid, items now has type str
            items = int(items)  # valid, items now has type int
 
+.. confval:: allow_redefinition
+
+    :type: boolean
+    :default: False
+
+    An alias to :confval:`allow_redefinition_old`, in mypy v2.0 this will point to
+    :confval:`allow_redefinition_new`, and will eventually became the default.
+
 .. confval:: local_partial_types
 
     :type: boolean
     :default: False
 
     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.
+    This will be enabled by default in mypy v2.0 release.
 
 .. confval:: disable_error_code
 

mypy/build.py

@@ -2764,7 +2764,7 @@ def semantic_analysis_pass1(self) -> None:
                 # Perform some low-key variable renaming when assignments can't
                 # widen inferred types
                 self.tree.accept(LimitedVariableRenameVisitor())
-            if options.allow_redefinition:
+            if options.allow_redefinition_old:
                 # Perform more renaming across the AST to allow variable redefinitions
                 self.tree.accept(VariableRenameVisitor())
         self.time_spent_us += time_spent_us(t0)

mypy/config_parser.py

@@ -504,7 +504,12 @@ def parse_section(
 
     for key in section:
         invert = False
+        # Here we use `key` for original config section key, and `options_key` for
+        # the corresponding Options attribute.
         options_key = key
+        # Match aliasing for command line flag.
+        if key.endswith("allow_redefinition"):
+            options_key += "_old"
         if key in config_types:
             ct = config_types[key]
         elif key in invalid_options:
@@ -515,7 +520,7 @@ def parse_section(
             )
             continue
         else:
-            dv = getattr(template, key, None)
+            dv = getattr(template, options_key, None)
             if dv is None:
                 if key.endswith("_report"):
                     report_type = key[:-7].replace("_", "-")
@@ -526,17 +531,17 @@ def parse_section(
                     continue
                 if key.startswith("x_"):
                     pass  # Don't complain about `x_blah` flags
-                elif key.startswith("no_") and hasattr(template, key[3:]):
-                    options_key = key[3:]
+                elif key.startswith("no_") and hasattr(template, options_key[3:]):
+                    options_key = options_key[3:]
                     invert = True
-                elif key.startswith("allow") and hasattr(template, "dis" + key):
-                    options_key = "dis" + key
+                elif key.startswith("allow") and hasattr(template, "dis" + options_key):
+                    options_key = "dis" + options_key
                     invert = True
-                elif key.startswith("disallow") and hasattr(template, key[3:]):
-                    options_key = key[3:]
+                elif key.startswith("disallow") and hasattr(template, options_key[3:]):
+                    options_key = options_key[3:]
                     invert = True
-                elif key.startswith("show_") and hasattr(template, "hide_" + key[5:]):
-                    options_key = "hide_" + key[5:]
+                elif key.startswith("show_") and hasattr(template, "hide_" + options_key[5:]):
+                    options_key = "hide_" + options_key[5:]
                     invert = True
                 elif key == "strict":
                     pass  # Special handling below

mypy/main.py

@@ -891,6 +891,15 @@ def add_invertible_flag(
         "--allow-redefinition",
         default=False,
         strict_flag=False,
+        help="Alias to --allow-redefinition-old; will point to --allow-redefinition-new in v2.0",
+        group=strictness_group,
+        dest="allow_redefinition_old",
+    )
+
+    add_invertible_flag(
+        "--allow-redefinition-old",
+        default=False,
+        strict_flag=False,
         help="Allow restricted, unconditional variable redefinition with a new type",
         group=strictness_group,
     )
@@ -899,7 +908,7 @@ def add_invertible_flag(
         "--allow-redefinition-new",
         default=False,
         strict_flag=False,
-        help="Allow more flexible variable redefinition semantics (experimental)",
+        help="Allow more flexible variable redefinition semantics",
         group=strictness_group,
     )
 

mypy/options.py

@@ -21,7 +21,7 @@ class BuildType:
 
 PER_MODULE_OPTIONS: Final = {
     # Please keep this list sorted
-    "allow_redefinition",
+    "allow_redefinition_old",
     "allow_redefinition_new",
     "allow_untyped_globals",
     "always_false",
@@ -222,10 +222,10 @@ def __init__(self) -> None:
 
         # Allow variable to be redefined with an arbitrary type in the same block
         # and the same nesting level as the initialization
-        self.allow_redefinition = False
+        self.allow_redefinition_old = False
 
         # Allow flexible variable redefinition with an arbitrary type, in different
-        # blocks and and at different nesting levels
+        # blocks and at different nesting levels
         self.allow_redefinition_new = False
 
         # Prohibit equality, identity, and container checks for non-overlapping types.

mypyc/irbuild/builder.py

@@ -1531,7 +1531,7 @@ def get_default() -> Value:
 
 
 def remangle_redefinition_name(name: str) -> str:
-    """Remangle names produced by mypy when allow-redefinition is used and a name
+    """Remangle names produced by mypy when allow-redefinition-old is used and a name
     is used with multiple types within a single block.
 
     We only need to do this for locals, because the name is used as the name of the register;

mypyc/test-data/irbuild-basic.test

@@ -3469,7 +3469,7 @@ L4:
     return 1
 
 [case testLocalRedefinition]
-# mypy: allow-redefinition
+# mypy: allow-redefinition-old
 def f() -> None:
     i = 0
     i += 1

mypyc/test-data/run-misc.test

@@ -1134,7 +1134,7 @@ def test_underscore() -> None:
     B()
 
 [case testGlobalRedefinition_toplevel]
-# mypy: allow-redefinition
+# mypy: allow-redefinition-old
 i = 0
 i += 1
 i = "foo"

mypyc/test-data/run-vecs-misc.test

@@ -5,7 +5,7 @@
 -- vec[i64] test cases are in run-vecs-i64.test.
 
 [case testVecMiscBasicOps_librt_experimental]
-# mypy: allow-redefinition
+# mypy: allow-redefinition-old
 
 from typing import Any, cast
 from mypy_extensions import i64, i32, i16, u8