Rename partially-defined error codes (#14267)

Rename `partially-defined` to `possibly-undefined` and `use-before-def`
to `used-before-def`.

Ref #14226

Author: cdce8p

mypy/build.py

@@ -50,7 +50,7 @@
 from mypy.indirection import TypeIndirectionVisitor
 from mypy.messages import MessageBuilder
 from mypy.nodes import Import, ImportAll, ImportBase, ImportFrom, MypyFile, SymbolTable, TypeInfo
-from mypy.partially_defined import PartiallyDefinedVariableVisitor
+from mypy.partially_defined import PossiblyUndefinedVariableVisitor
 from mypy.semanal import SemanticAnalyzer
 from mypy.semanal_pass1 import SemanticAnalyzerPreAnalysis
 from mypy.util import (
@@ -2347,18 +2347,18 @@ def type_check_second_pass(self) -> bool:
         self.time_spent_us += time_spent_us(t0)
         return result
 
-    def detect_partially_defined_vars(self, type_map: dict[Expression, Type]) -> None:
+    def detect_possibly_undefined_vars(self, type_map: dict[Expression, Type]) -> None:
         assert self.tree is not None, "Internal error: method must be called on parsed file only"
         if self.tree.is_stub:
             # We skip stub files because they aren't actually executed.
             return
         manager = self.manager
         if manager.errors.is_error_code_enabled(
-            codes.PARTIALLY_DEFINED
-        ) or manager.errors.is_error_code_enabled(codes.USE_BEFORE_DEF):
+            codes.POSSIBLY_UNDEFINED
+        ) or manager.errors.is_error_code_enabled(codes.USED_BEFORE_DEF):
             manager.errors.set_file(self.xpath, self.tree.fullname, options=manager.options)
             self.tree.accept(
-                PartiallyDefinedVariableVisitor(
+                PossiblyUndefinedVariableVisitor(
                     MessageBuilder(manager.errors, manager.modules), type_map, manager.options
                 )
             )
@@ -3412,7 +3412,7 @@ def process_stale_scc(graph: Graph, scc: list[str], manager: BuildManager) -> No
         graph[id].type_check_first_pass()
         if not graph[id].type_checker().deferred_nodes:
             unfinished_modules.discard(id)
-            graph[id].detect_partially_defined_vars(graph[id].type_map())
+            graph[id].detect_possibly_undefined_vars(graph[id].type_map())
             graph[id].finish_passes()
 
     while unfinished_modules:
@@ -3421,7 +3421,7 @@ def process_stale_scc(graph: Graph, scc: list[str], manager: BuildManager) -> No
                 continue
             if not graph[id].type_check_second_pass():
                 unfinished_modules.discard(id)
-                graph[id].detect_partially_defined_vars(graph[id].type_map())
+                graph[id].detect_possibly_undefined_vars(graph[id].type_map())
                 graph[id].finish_passes()
     for id in stale:
         graph[id].generate_unused_ignore_notes()

mypy/errorcodes.py

@@ -140,8 +140,8 @@ def __str__(self) -> str:
 ANNOTATION_UNCHECKED = ErrorCode(
     "annotation-unchecked", "Notify about type annotations in unchecked functions", "General"
 )
-PARTIALLY_DEFINED: Final[ErrorCode] = ErrorCode(
-    "partially-defined",
+POSSIBLY_UNDEFINED: Final[ErrorCode] = ErrorCode(
+    "possibly-undefined",
     "Warn about variables that are defined only in some execution paths",
     "General",
     default_enabled=False,
@@ -192,8 +192,8 @@ def __str__(self) -> str:
     "General",
     default_enabled=False,
 )
-USE_BEFORE_DEF: Final[ErrorCode] = ErrorCode(
-    "use-before-def",
+USED_BEFORE_DEF: Final[ErrorCode] = ErrorCode(
+    "used-before-def",
     "Warn about variables that are used before they are defined",
     "General",
     default_enabled=False,

mypy/messages.py

@@ -1229,10 +1229,10 @@ def undefined_in_superclass(self, member: str, context: Context) -> None:
         self.fail(f'"{member}" undefined in superclass', context)
 
     def variable_may_be_undefined(self, name: str, context: Context) -> None:
-        self.fail(f'Name "{name}" may be undefined', context, code=codes.PARTIALLY_DEFINED)
+        self.fail(f'Name "{name}" may be undefined', context, code=codes.POSSIBLY_UNDEFINED)
 
     def var_used_before_def(self, name: str, context: Context) -> None:
-        self.fail(f'Name "{name}" is used before definition', context, code=codes.USE_BEFORE_DEF)
+        self.fail(f'Name "{name}" is used before definition', context, code=codes.USED_BEFORE_DEF)
 
     def first_argument_for_super_must_be_type(self, actual: Type, context: Context) -> None:
         actual = get_proper_type(actual)

mypy/partially_defined.py

@@ -104,7 +104,7 @@ def skip_branch(self) -> None:
         assert len(self.branches) > 0
         self.branches[-1].skipped = True
 
-    def is_partially_defined(self, name: str) -> bool:
+    def is_possibly_undefined(self, name: str) -> bool:
         assert len(self.branches) > 0
         return name in self.branches[-1].may_be_defined
 
@@ -213,10 +213,10 @@ def pop_undefined_ref(self, name: str) -> set[NameExpr]:
         assert len(self.scopes) > 0
         return self._scope().pop_undefined_ref(name)
 
-    def is_partially_defined(self, name: str) -> bool:
+    def is_possibly_undefined(self, name: str) -> bool:
         assert len(self._scope().branch_stmts) > 0
         # A variable is undefined if it's in a set of `may_be_defined` but not in `must_be_defined`.
-        return self._scope().branch_stmts[-1].is_partially_defined(name)
+        return self._scope().branch_stmts[-1].is_possibly_undefined(name)
 
     def is_defined_in_different_branch(self, name: str) -> bool:
         """This will return true if a variable is defined in a branch that's not the current branch."""
@@ -243,7 +243,7 @@ def __init__(self) -> None:
         self.has_break = False
 
 
-class PartiallyDefinedVariableVisitor(ExtendedTraverserVisitor):
+class PossiblyUndefinedVariableVisitor(ExtendedTraverserVisitor):
     """Detects the following cases:
     - A variable that's defined only part of the time.
     - If a variable is used before definition
@@ -253,7 +253,7 @@ class PartiallyDefinedVariableVisitor(ExtendedTraverserVisitor):
         x = 1
     print(x)  # Error: "x" may be undefined.
 
-    Example of a use before definition:
+    Example of a used before definition:
     x = y
     y: int = 2
 
@@ -273,15 +273,15 @@ def __init__(
             self.tracker.record_definition(name)
 
     def var_used_before_def(self, name: str, context: Context) -> None:
-        if self.msg.errors.is_error_code_enabled(errorcodes.USE_BEFORE_DEF):
+        if self.msg.errors.is_error_code_enabled(errorcodes.USED_BEFORE_DEF):
             self.msg.var_used_before_def(name, context)
 
     def variable_may_be_undefined(self, name: str, context: Context) -> None:
-        if self.msg.errors.is_error_code_enabled(errorcodes.PARTIALLY_DEFINED):
+        if self.msg.errors.is_error_code_enabled(errorcodes.POSSIBLY_UNDEFINED):
             self.msg.variable_may_be_undefined(name, context)
 
     def process_definition(self, name: str) -> None:
-        # Was this name previously used? If yes, it's a use-before-definition error.
+        # Was this name previously used? If yes, it's a used-before-definition error.
         refs = self.tracker.pop_undefined_ref(name)
         for ref in refs:
             self.var_used_before_def(name, ref)
@@ -471,7 +471,7 @@ def visit_starred_pattern(self, o: StarredPattern) -> None:
     def visit_name_expr(self, o: NameExpr) -> None:
         if refers_to_builtin(o):
             return
-        if self.tracker.is_partially_defined(o.name):
+        if self.tracker.is_possibly_undefined(o.name):
             # A variable is only defined in some branches.
             self.variable_may_be_undefined(o.name, o)
             # We don't want to report the error on the same variable multiple times.
@@ -488,7 +488,7 @@ def visit_name_expr(self, o: NameExpr) -> None:
             # 2. The variable is defined later in the code.
             # Case (1) will be caught by semantic analyzer. Case (2) is a forward ref that should
             # be caught by this visitor. Save the ref for later, so that if we see a definition,
-            # we know it's a use-before-definition scenario.
+            # we know it's a used-before-definition scenario.
             self.tracker.record_undefined_ref(o)
         super().visit_name_expr(o)
 

mypy/server/update.py

@@ -662,7 +662,7 @@ def restore(ids: list[str]) -> None:
     state.type_checker().reset()
     state.type_check_first_pass()
     state.type_check_second_pass()
-    state.detect_partially_defined_vars(state.type_map())
+    state.detect_possibly_undefined_vars(state.type_map())
     t2 = time.time()
     state.finish_passes()
     t3 = time.time()