Merge transform code into a single class

python · JukkaL · Jan 21, 2019 · Sep 20, 2018 · Sep 20, 2018 · Sep 20, 2018
commit 712669c5debfdcd622c1ce7d3fbfe367736dc287
diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -82,7 +82,7 @@
 from mypy import experiments
 from mypy.plugin import Plugin, ClassDefContext, SemanticAnalyzerPluginInterface
10000
 from mypy.util import get_prefix, correct_relative_import, unmangle
-from mypy.semanal_shared import SemanticAnalyzerInterface, set_callable_name, VarDefAnalyzer
+from mypy.semanal_shared import SemanticAnalyzerInterface, set_callable_name
 from mypy.scope import Scope
 from mypy.semanal_namedtuple import NamedTupleAnalyzer, NAMEDTUPLE_PROHIBITED_NAMES
 from mypy.semanal_typeddict import TypedDictAnalyzer

diff --git a/mypy/semanal_redef.py b/mypy/semanal_redef.py
@@ -2,11 +2,10 @@
 
 from mypy.nodes import (
     Block, AssignmentStmt, NameExpr, MypyFile, FuncDef, Lvalue, ListExpr, TupleExpr, TempNode,
-    WhileStmt, ForStmt, BreakStmt, ContinueStmt, TryStmt, WithStmt, StarExpr, ImportFrom, MemberExpr,
-    IndexExpr
+    WhileStmt, ForStmt, BreakStmt, ContinueStmt, TryStmt, WithStmt, StarExpr, ImportFrom,
+    MemberExpr, IndexExpr
 )
 from mypy.traverser import TraverserVisitor
-from mypy.semanal_shared import VarDefAnalyzer
 
 
 class VariableRenameVisitor(TraverserVisitor):
@@ -16,15 +15,22 @@ class VariableRenameVisitor(TraverserVisitor):
 
       x = 0
       f(x)
+
       x = ''
       g(x)
 
-    It can be renamed to this:
+    It would be transformed to this:
+
+      x' = 0
+      f(x')
 
-      x~ = 0
-      f(x~)
       x = ''
-      g(X)
+      g(x)
+
+    There will be two independent variables (x' and x) that will have separate
+    inferred types.
+
+    Renaming only happens for assignments within the same block.
 
     TODO:
      * renaming in functions (argument redef)
@@ -53,69 +59,82 @@ class VariableRenameVisitor(TraverserVisitor):
     """
 
     def __init__(self) -> None:
-        self.var_def_analyzer = VarDefAnalyzer()
+        # Counter for labeling new blocks
+        self.block_id = 0
+        self.disallow_redef_depth = 0
+        self.loop_depth = 0
+        # Map block id to loop depth.
+        self.block_loop_depth = {}  # type: Dict[int, int]
+        # Stack of block ids being processed.
+        self.blocks = []  # type: List[int]
+        # List of scopes; each scope maps short name to block id.
+        self.var_blocks = [{}]  # type: List[Dict[str, int]]
+        # Variables which have no assigned value yet (e.g., "x: t" but no assigment).
+        # Assignment in any block is considered an initialization.
+        self.uninitialized = set()  # type: Set[str]
+
+        # References to variables
         self.refs = []  # type: List[Dict[str, List[List[NameExpr]]]]
 
     def visit_mypy_file(self, file_node: MypyFile) -> None:
-        self.var_def_analyzer.clear()
-        self.var_def_analyzer.enter_block()
+        self.clear()
+        self.enter_bloc
10000
k()
         self.refs.append({})
         for d in file_node.defs:
             d.accept(self)
         self.flush_refs()
-        self.var_def_analyzer.leave_block()
+        self.leave_block()
 
     def visit_func_def(self, fdef: FuncDef) -> None:
         # Conservatively do not allow variable defined before a function to
         # be redefined later, since function could refer to either definition.
-        self.var_def_analyzer.reject_redefinition_of_vars_in_scope()
-        self.var_def_analyzer.process_assignment(fdef.name(), can_be_redefined=False)
-        self.var_def_analyzer.enter_scope()
+        self.reject_redefinition_of_vars_in_scope()
+        self.process_assignment(fdef.name(), can_be_redefined=False)
+        self.enter_scope()
         self.refs.append({})
 
         for arg in fdef.arguments:
             name = arg.variable.name()
-            self.var_def_analyzer.process_assignment(arg.variable.name(),
-                                                     can_be_redefined=True)
+            self.process_assignment(arg.variable.name(), can_be_redefined=True)
             self.handle_arg(name)
 
         self.visit_block(fdef.body, enter=False)
         self.flush_refs()
-        self.var_def_analyzer.leave_scope()
+        self.leave_scope()
 
     def visit_block(self, block: Block, enter: bool = True) -> None:
         if enter:
-            self.var_def_analyzer.enter_block()
+            self.enter_block()
         super().visit_block(block)
         if enter:
-            self.var_def_analyzer.leave_block()
+            self.leave_block()
 
     def visit_while_stmt(self, stmt: WhileStmt) -> None:
-        self.var_def_analyzer.enter_loop()
+        self.enter_loop()
         super().visit_while_stmt(stmt)
-        self.var_def_analyzer.leave_loop()
+        self.leave_loop()
 
     def visit_for_stmt(self, stmt: ForStmt) -> None:
         self.analyze_lvalue(stmt.index, True)
-        self.var_def_analyzer.enter_loop()
+        self.enter_loop()
         super().visit_for_stmt(stmt)
-        self.var_def_analyzer.leave_loop()
+        self.leave_loop()
 
     def visit_break_stmt(self, stmt: BreakStmt) -> None:
-        self.var_def_analyzer.reject_redefinition_of_vars_in_loop()
+        self.reject_redefinition_of_vars_in_loop()
 
     def visit_continue_stmt(self, stmt: ContinueStmt) -> None:
-        self.var_def_analyzer.reject_redefinition_of_vars_in_loop()
+        self.reject_redefinition_of_vars_in_loop()
 
     def visit_try_stmt(self, stmt: TryStmt) -> None:
-        self.var_def_analyzer.enter_with_or_try()
+        self.enter_with_or_try()
         super().visit_try_stmt(stmt)
-        self.var_def_analyzer.leave_with_or_try()
+        self.leave_with_or_try()
 
     def visit_with_stmt(self, stmt: WithStmt) -> None:
-        self.var_def_analyzer.enter_with_or_try()
+        self.enter_with_or_try()
         super().visit_with_stmt(stmt)
-        self.var_def_analyzer.leave_with_or_try()
+        self.leave_with_or_try()
 
     def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
         has_initializer = not isinstance(s.rvalue, TempNode)
@@ -126,7 +145,7 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
     def analyze_lvalue(self, lvalue: Lvalue, has_initializer: bool) -> None:
         if isinstance(lvalue, NameExpr):
             name = lvalue.name
-            is_new = self.var_def_analyzer.process_assignment(name, True, not has_initializer)
+            is_new = self.process_assignment(name, True, not has_initializer)
             if is_new: # and name != '_':  # Underscore gets special handling later
                 self.handle_def(lvalue)
             else:
@@ -144,7 +163,7 @@ def analyze_lvalue(self, lvalue: Lvalue, has_initializer: bool) -> None:
 
     def visit_import_from(self, imp: ImportFrom) -> None:
         for id, as_id in imp.names:
-            self.var_def_analyzer.process_assignment(as_id or id, False, False)
+            self.process_assignment(as_id or id, False, False)
 
     def visit_name_expr(self, expr: NameExpr) -> None:
         self.handle_ref(expr)
@@ -166,7 +185,7 @@ def handle_ref(self, expr: NameExpr) -> None:
             names[-1].append(expr)
 
     def flush_refs(self) -> None:
-        is_func = self.var_def_analyzer.is_nested()
+        is_func = self.is_nested()
         for name, refs in self.refs[-1].items():
             if len(refs) == 1:
                 continue
@@ -183,3 +202,90 @@ def rename_refs(self, names: List[NameExpr], index: int) -> None:
         new_name = name + "'" * (index + 1)
         for expr in names:
             expr.name = new_name
+
+    # ----
+
+    def clear(self) -> None:
+        self.blocks = []
+        self.var_blocks = [{}]
+
+    def enter_block(self) -> None:
+        self.block_id += 1
+        self.blocks.append(self.block_id)
+        self.block_loop_depth[self.block_id] = self.loop_depth
+
+    def leave_block(self) -> None:
+        self.blocks.pop()
+
+    def enter_with_or_try(self) -> None:
+        self.disallow_redef_depth += 1
+
+    def leave_with_or_try(self) -> None:
+        self.disallow_redef_depth -= 1
+
+    def enter_loop(self) -> None:
+        self.loop_depth += 1
+
+    def leave_loop(self) -> None:
+        self.loop_depth -= 1
+
+    def current_block(self) -> int:
+        return self.blocks[-1]
+
+    def enter_scope(self) -> None:
+        self.var_blocks.append({})
+
+    def leave_scope(self) -> None:
+        self.var_blocks.pop()
+
+    def is_nested(self) -> int:
+        return len(self.var_blocks) > 1
+
+    def reject_redefinition_of_vars_in_scope(self) -> None:
+        """Make it impossible to redefine defined variables in the current scope.
+
+        This is used if we encounter a function definition or break/continue that
+        can make it ambiguous which definition is live.
+        """
+        var_blocks = self.var_blocks[-1]
+        for key in var_blocks:
+            var_blocks[key] = -1
+
+    def reject_redefinition_of_vars_in_loop(self) -> None:
+        var_blocks = self.var_blocks[-1]
+        for key, block in var_blocks.items():
+            if self.block_loop_depth.get(block) == self.loop_depth:
+                var_blocks[key] = -1
+
+    def process_assignment(self, name: str, can_be_redefined: bool, no_value: bool = False) -> bool:
+        """Record assignment to given name and return True if it defines a new name.
+
+        Args:
+            can_be_redefined: If True, allows assignment in the same block to redefine the name
+            no_value: If True, the first assignment we encounter will not be considered to redefine
+                this but to initilize it (in any block)
+        """
+        if self.disallow_redef_depth > 0:
+            can_be_redefined = False
+        block = self.current_block()
+        var_blocks = self.var_blocks[-1]
+        uninitialized = self.uninitialized
+        existing_no_value = name in self.uninitialized
+        if no_value:
+            uninitialized.add(name)
+        else:
+            uninitialized.discard(name)
+        if name not in var_blocks:
+            # New definition
+            if can_be_redefined:
+                var_blocks[name] = block
+            else:
+                # This doesn't support arbitrary redefinition.
+                # TODO: Make this less restricted.
+                var_blocks[name] = -1
+            return True
+        elif var_blocks[name] == block and not existing_no_value:
+            # Redefinition
+            return True
+        else:
+            return False
diff --git a/mypy/semanal_shared.py b/mypy/semanal_shared.py
@@ -150,115 +150,3 @@ def set_callable_name(sig: Type, fdef: FuncDef) -> Type:
             return sig.with_name(fdef.name())
     else:
         return sig
-
-
-class VarDefAnalyzer:
-    """Helper class that keeps track of variable redefinitions.
-
-    This decides whether an assignment to an existing variable should define a new variable.
-    This can happen if there are multiple assignments to a variable within the same block:
-
-        x = 0
-        x = str(x)  # Defines a new 'x'
-
-    Since we now have two distinct 'x' variables, they can have independent inferred types.
-    """
-
-    def __init__(self) -> None:
-        self.block_id = 0
-        self.disallow_redef_depth = 0
-        self.loop_depth = 0
-        # Map block id to loop depth.
-        self.block_loop_depth = {}  # type: Dict[int, int]
-        # Stack of block ids being processed.
-        self.blocks = []  # type: List[int]
-        # List of scopes; each scope maps short name to block id.
-        self.var_blocks = [{}]  # type: List[Dict[str, int]]
-        # Variables which have no assigned value yet (e.g., "x: t" but no assigment).
-        # Assignment in any block is considered an initialization.
-        self.uninitialized = set()  # type: Set[str]
-
-    def clear(self) -> None:
-        self.blocks = []
-        self.var_blocks = [{}]
-
-    def enter_block(self) -> None:
-        self.block_id += 1
-        self.blocks.append(self.block_id)
-        self.block_loop_depth[self.block_id] = self.loop_depth
-
-    def leave_block(self) -> None:
-        self.blocks.pop()
-
-    def enter_with_or_try(self) -> None:
-        self.disallow_redef_depth += 1
-
-    def leave_with_or_try(self) -> None:
-        self.disallow_redef_depth -= 1
-
-    def enter_loop(self) -> None:
-        self.loop_depth += 1
-
-    def leave_loop(self) -> None:
-        self.loop_depth -= 1
-
-    def current_block(self) -> int:
-        return self.blocks[-1]
-
-    def enter_scope(self) -> None:
-        self.var_blocks.append({})
-
-    def leave_scope(self) -> None:
-        self.var_blocks.pop()
-
-    def is_nested(self) -> int:
-        return len(self.var_blocks) > 1
-
-    def reject_redefinition_of_vars_in_scope(self) -> None:
-        """Make it impossible to redefine defined variables in the current scope.
-
-        This is used if we encounter a function definition or break/continue that
-        can make it ambiguous which definition is live.
-        """
-        var_blocks = self.var_blocks[-1]
-        for key in var_blocks:
-            var_blocks[key] = -1
-
-    def reject_redefinition_of_vars_in_loop(self) -> None:
-        var_blocks = self.var_blocks[-1]
-        for key, block in var_blocks.items():
-            if self.block_loop_depth.get(block) == self.loop_depth:
-                var_blocks[key] = -1
-
-    def process_assignment(self, name: str, can_be_redefined: bool, no_value: bool = False) -> bool:
-        """Record assignment to given name and return True if it defines a new name.
-
-        Args:
-            can_be_redefined: If True, allows assignment in the same block to redefine the name
-            no_value: If True, the first assignment we encounter will not be considered to redefine
-                this but to initilize it (in any block)
-        """
-        if self.disallow_redef_depth > 0:
-            can_be_redefined = False
-        block = self.current_block()
-        var_blocks = self.var_blocks[-1]
-        uninitialized = self.uninitialized
-        existing_no_value = name in self.uninitialized
-        if no_value:
-            uninitialized.add(name)
-        else:
-            uninitialized.discard(name)
-            if name not in var_blocks:
-            # New definition
-            if can_be_redefined:
-                var_blocks[name] = block
-            else:
-                # This doesn't support arbitrary redefinition.
-                # TODO: Make this less restricted.
-                var_blocks[name] = -1
-            return True
-        elif var_blocks[name] == block and not existing_no_value:
-            # Redefinition
-            return True
-        else:
-            return False