Remove debug prints

Author: ambv

mypy/partially_defined.py

@@ -48,16 +48,6 @@
 from mypy.types import Type, UninhabitedType, get_proper_type
 
 
-def _ambv(s: str) -> None:
-    assert s
-    pass  # print("DEBUG:", s)
-
-
-def _ambv_cont(s: str) -> None:
-    assert s
-    pass  # print(s)
-
-
 class BranchState:
     """BranchState contains information about variable definition at the end of a branching statement.
     `if` and `match` are examples of branching statements.
@@ -127,9 +117,6 @@ def delete_var(self, name: str) -> None:
     def record_nested_branch(self, state: BranchState) -> None:
         assert len(self.branches) > 0
         current_branch = self.branches[-1]
-        _ambv(
-            f"record_nested_branch: state.must={state.must_be_defined if 'value' in state.must_be_defined else '...'}, state.may={'value' if 'value' in state.may_be_defined else '...'}, state.skipped={state.skipped}"
-        )
         if state.skipped:
             current_branch.skipped = True
             return
@@ -167,17 +154,6 @@ def done(self) -> BranchState:
             all_vars.update(b.must_be_defined)
         # For the rest of the things, we only care about branches that weren't skipped.
         non_skipped_branches = [b for b in self.branches if not b.skipped]
-        import sys
-
-        _called_by = sys._getframe(2).f_code.co_name
-        _ambv(
-            f"done {_called_by}: branches={len(self.branches)}, non_skipped={len(non_skipped_branches)}"
-        )
-        for i, b in enumerate(self.branches):
-            has_value = "value" in b.must_be_defined or "value" in b.may_be_defined
-            _ambv_cont(
-                f"  Branch {i}: has_value={has_value}, skipped={b.skipped}, must={b.must_be_defined}, may={b.may_be_defined}"
-            )
         if non_skipped_branches:
             must_be_defined = non_skipped_branches[0].must_be_defined
             for b in non_skipped_branches[1:]:
@@ -187,7 +163,6 @@ def done(self) -> BranchState:
         # Everything that wasn't defined in all branches but was defined
         # in at least one branch should be in `may_be_defined`!
         may_be_defined = all_vars.difference(must_be_defined)
-        _ambv_cont(f"  Result: must={must_be_defined}, may={may_be_defined}")
         return BranchState(
             must_be_defined=must_be_defined,
             may_be_defined=may_be_defined,
@@ -363,10 +338,6 @@ def __init__(
         for name in implicit_module_attrs:
             self.tracker.record_definition(name)
 
-    # def visit_block(self, block: Block, /) -> None:
-    #    _ambv(f"PossiblyUndefinedVariableVisitor visiting {block}")
-    #    super().visit_block(block)
-
     def var_used_before_def(self, name: str, context: Context) -> None:
         if self.msg.errors.is_error_code_enabled(errorcodes.USED_BEFORE_DEF):
             self.msg.var_used_before_def(name, context)
@@ -380,9 +351,6 @@ def process_definition(self, name: str) -> None:
         if not self.tracker.in_scope(ScopeType.Class):
             refs = self.tracker.pop_undefined_ref(name)
             for ref in refs:
-                _ambv(
-                    f"process_definition for {name}, ref at line {ref.line}, loops={bool(self.loops)}"
-                )
                 if self.loops:
                     self.variable_may_be_undefined(name, ref)
                 else:
@@ -404,9 +372,6 @@ def visit_nonlocal_decl(self, o: NonlocalDecl) -> None:
 
     def process_lvalue(self, lvalue: Lvalue | None) -> None:
         if isinstance(lvalue, NameExpr):
-            _ambv(
-                f"process_lvalue calling process_definition for {lvalue.name} at line {lvalue.line}"
-            )
             self.process_definition(lvalue.name)
         elif isinstance(lvalue, StarExpr):
             self.process_lvalue(lvalue.expr)
@@ -415,7 +380,6 @@ def process_lvalue(self, lvalue: Lvalue | None) -> None:
                 self.process_lvalue(item)
 
     def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
-        _ambv(f"visit_assignment_stmt at line {o.line}")
         for lvalue in o.lvalues:
             self.process_lvalue(lvalue)
         super().visit_assignment_stmt(o)
@@ -494,34 +458,20 @@ def visit_dictionary_comprehension(self, o: DictionaryComprehension) -> None:
         self.tracker.exit_scope()
 
     def visit_for_stmt(self, o: ForStmt) -> None:
-        _ambv(f"visit_for_stmt: line {o.line}")
         o.expr.accept(self)
         self.process_lvalue(o.index)
         o.index.accept(self)
         self.tracker.start_branch_statement()
         loop = Loop()
         self.loops.append(loop)
-        _ambv(
-            f"visit_for_stmt: Before body, current state: {self.tracker._scope().branch_stmts[-1].branches[-1].must_be_defined}, may={self.tracker._scope().branch_stmts[-1].branches[-1].may_be_defined}"
-        )
         o.body.accept(self)
-        _ambv(f"visit_for_stmt: after body, has_break={loop.has_break}")
-        _ambv(
-            f"visit_for_stmt: After body, current state: {self.tracker._scope().branch_stmts[-1].branches[-1].must_be_defined}, may={self.tracker._scope().branch_stmts[-1].branches[-1].may_be_defined}"
-        )
         self.tracker.next_branch()
-        _ambv(
-            f"visit_for_stmt: After next_branch, new branch state: {self.tracker._scope().branch_stmts[-1].branches[-1].must_be_defined}, may={self.tracker._scope().branch_stmts[-1].branches[-1].may_be_defined}"
-        )
         self.tracker.end_branch_statement()
         if o.else_body is not None:
             # If the loop has a `break` inside, `else` is executed conditionally.
             # If the loop doesn't have a `break` either the function will return or
             # execute the `else`.
             has_break = loop.has_break
-            _ambv(
-                f"visit_for_stmt: else_body present, has_break={has_break}, break_vars={loop.break_vars}"
-            )
             if has_break:
                 self.tracker.start_branch_statement()
                 if loop.break_vars is not None:
@@ -552,7 +502,6 @@ def visit_raise_stmt(self, o: RaiseStmt) -> None:
         self.tracker.skip_branch()
 
     def visit_continue_stmt(self, o: ContinueStmt) -> None:
-        _ambv(f"continue at line {o.line}, skipping branch")
         super().visit_continue_stmt(o)
         self.tracker.skip_branch()
 
@@ -609,7 +558,6 @@ def f() -> int:
         self.try_depth -= 1
 
     def process_try_stmt(self, o: TryStmt) -> None:
-        _ambv(f"process_try_stmt: line {o.line}, handlers={len(o.handlers)}")
         """
         Processes try statement decomposing it into the following:
         if ...:
@@ -685,9 +633,6 @@ def visit_starred_pattern(self, o: StarredPattern) -> None:
     def visit_name_expr(self, o: NameExpr) -> None:
         if o.name in self.builtins and self.tracker.in_scope(ScopeType.Global):
             return
-        _ambv(
-            f"visit_name_expr {o.name} at line {o.line}, possibly_undefined={self.tracker.is_possibly_undefined(o.name)}, defined_in_different_branch={self.tracker.is_defined_in_different_branch(o.name)}, is_undefined={self.tracker.is_undefined(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)
@@ -708,7 +653,6 @@ def visit_name_expr(self, o: NameExpr) -> None:
             # 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 used-before-definition scenario.
-            _ambv(f"Recording undefined ref for {o.name} at line {o.line}")
             self.tracker.record_undefined_ref(o)
         super().visit_name_expr(o)