Refactor: simplify VarDef (close #84)

Author: JukkaL

checker.py

@@ -133,16 +133,16 @@ class TypeChecker(NodeVisitor<Type>):
         # Type check initializer.
         if defn.init:
             # There is an initializer.
-            if defn.items[0][1]:
+            if defn.items[0].type:
                 # Explicit types.
                 if len(defn.items) == 1:
-                    self.check_single_assignment(defn.items[0][1], None,
+                    self.check_single_assignment(defn.items[0].type, None,
                                                  defn.init, defn.init)
                 else:
                     # Multiple assignment.
                     Type[] lvt = []
-                    for v, t in defn.items:
-                        lvt.append(t)
+                    for v in defn.items:
+                        lvt.append(v.type)
                     self.check_multi_assignment(
                         lvt, <tuple<Type, Node>> [None] * len(lvt),
                         defn.init, defn.init)
@@ -152,13 +152,10 @@ class TypeChecker(NodeVisitor<Type>):
                     # Infer local variable type if there is an initializer
                     # except if the# definition is at the top level (outside a
                     # function).
-                    Var[] names = []
-                    for vv, tt in defn.items:
-                        names.append(vv)
-                    self.infer_local_variable_type(names, init_type, defn)
+                    self.infer_local_variable_type(defn.items, init_type, defn)
         else:
             # No initializer
-            if (defn.kind == LDEF and not defn.items[0][1] and
+            if (defn.kind == LDEF and not defn.items[0].type and
                     not defn.is_top_level and not self.is_dynamic_function()):
                 self.fail(messages.NEED_ANNOTATION_FOR_VAR, defn)
 

icode.py

@@ -421,7 +421,7 @@ class IcodeBuilder(NodeVisitor<int>):
 
     int visit_var_def(self, VarDef d):
         assert len(d.items) == 1
-        var = d.items[0][0]
+        var = d.items[0]
         if d.kind == nodes.LDEF:
             reg = self.add_local(var)
             if d.init:

nodes.py

@@ -274,8 +274,9 @@ class Var(Node, AccessorNode, SymNode):
     bool is_self     # Is this the first argument to an ordinary method
                      # (usually "self")?
 
-    void __init__(self, str name):
+    void __init__(self, str name, mtypes.Type type=None):
         self._name = name
+        self.type = type
         self.is_init = False
         self.is_self = False
 
@@ -319,32 +320,31 @@ class TypeDef(Node):
 
 
 class VarDef(Node):
-    tuple<Var, mtypes.Type>[] items
+    Var[] items
     int kind          # LDEF/GDEF/MDEF/...
     Node init         # Expression or None
     bool is_top_level # Is the definition at the top level (not within
                       # a function or a type)?
     bool is_init
 
-    void __init__(self, tuple<Var, mtypes.Type>[] items,
-                  bool is_top_level, Node init=None):
+    void __init__(self, Var[] items, bool is_top_level, Node init=None):
         self.items = items
         self.is_top_level = is_top_level
         self.init = init
         self.is_init = init is not None
 
     TypeInfo info(self):
-        return self.items[0][0].info
+        return self.items[0].info
 
     Node set_line(self, Token tok):
         super().set_line(tok)
-        for n, t in self.items:
+        for n in self.items:
             n.line = self.line
         return self
 
     Node set_line(self, int tok):
         super().set_line(tok)
-        for n, t in self.items:
+        for n in self.items:
             n.line = self.line
         return self
 

output.py

@@ -152,8 +152,8 @@ def function_header(self, o, arg_repr, arg_kinds, pre_args_func=None,
     def visit_var_def(self, o):
         r = o.repr
         if r:
-            for v, t in o.items:
-                self.type(t)
+            for v in o.items:
+                self.type(v.type)
                 self.node(v)
             self.token(r.assign)
             self.node(o.init)

parse.py

@@ -524,26 +524,26 @@ def parse_type_def(self, is_interface):
 
     VarDef parse_var_def(self, Type typ):
         """Parse variable definition with explicit types."""
-        n = self.parse_var_list(typ)
+        vars = self.parse_var_list(typ)
         Node init = None
         assign_token = none
         if self.current_str() == '=':
             assign_token = self.expect('=')
             init = self.parse_expression(0)
-        for nn, t in n:
-            nn.is_init = init is not None
+        for v in vars:
+            v.is_init = init is not None
         br = self.expect_break()
 
-        node = VarDef(n, self.is_at_top_level(), init)
+        node = VarDef(vars, self.is_at_top_level(), init)
         self.set_repr(node, noderepr.VarDefRepr(assign_token, br))
         return node
 
-    tuple<Var, Type>[] parse_var_list(self, Type first_type):
+    Var[] parse_var_list(self, Type first_type):
         """Parse a comma-separated list of variable names, potentially
         prefixed by type declarations.
         """
         tok = self.expect_type(Name)
-        n = [(Var(tok.string), first_type)]
+        n = [Var(tok.string, first_type)]
         r = [noderepr.VarRepr(tok, none)]
         while self.current_str() == ',':
             tok = self.expect(',')
@@ -553,10 +553,10 @@ def parse_type_def(self, is_interface):
             if self.is_at_type():
                 t = self.parse_type()
             tok = self.expect_type(Name)
-            n.append((Var(tok.string), t))
+            n.append(Var(tok.string, t))
             r.append(noderepr.VarRepr(tok, none))
         for i in range(len(n)):
-            self.set_repr(n[i][0], r[i])
+            self.set_repr(n[i], r[i])
         return n
 
     # Parsing statements

pprinter.py

@@ -72,10 +72,10 @@ class PrettyPrintVisitor(NodeVisitor):
         fdef.body.accept(self)
 
     void visit_var_def(self, VarDef vdef):
-        if vdef.items[0][0].name() != '__name__':
-            self.type(vdef.items[0][1])
+        if vdef.items[0].name() != '__name__':
+            self.type(vdef.items[0].type)
             self.string(' ')
-            self.string(vdef.items[0][0].name())
+            self.string(vdef.items[0].name())
             if vdef.init:
                 self.string(' = ')
                 self.node(vdef.init)

pythongen.py

@@ -144,9 +144,9 @@ def get_pre_whitespace(self, t):
     def visit_var_def(self, o):
         r = o.repr
         if r:
-            self.string(self.get_pre_whitespace(o.items[0][1]))
+            self.string(self.get_pre_whitespace(o.items[0].type))
             self.omit_next_space = True
-            for v, t in o.items:
+            for v in o.items:
                 self.node(v)
             if o.init:
                 self.token(r.assign)

semanal.py

@@ -92,7 +92,7 @@ class SemanticAnalyzer(NodeVisitor):
         self.global_decls = [set()]
 
         # Add implicit definition of '__name__'.
-        name_def = VarDef([(Var('__name__'), Any())], True)
+        name_def = VarDef([Var('__name__', Any())], True)
         defs.insert(0, name_def)
 
         for d in defs:
@@ -111,7 +111,7 @@ class SemanticAnalyzer(NodeVisitor):
         # Add implicit definition of 'None' to builtins, as we cannot define a
         # variable with a None type explicitly.
         if mod_id == 'builtins':
-            none_def = VarDef([(Var('None'), NoneTyp())], True)
+            none_def = VarDef([Var('None', NoneTyp())], True)
             defs.append(none_def)
             self.anal_var_def(none_def)
 
@@ -139,7 +139,7 @@ class SemanticAnalyzer(NodeVisitor):
         self.globals[d.name] = SymbolTableNode(GDEF, info, self.cur_mod_id)
 
     void anal_var_def(self, VarDef d):
-        for v, t in d.items:
+        for v in d.items:
             self.check_no_global(v.name(), d)
             v._full_name = self.qualified_name(v.name())
             self.globals[v.name()] = SymbolTableNode(GDEF, v, self.cur_mod_id)
@@ -356,12 +356,9 @@ class SemanticAnalyzer(NodeVisitor):
 
     void visit_var_def(self, VarDef defn):
         for i in range(len(defn.items)):
-            defn.items[i] = (defn.items[i][0],
-                             self.anal_type(defn.items[i][1]))
-            if defn.items[i][1]:
-                defn.items[i][0].type = defn.items[i][1]
+            defn.items[i].type = self.anal_type(defn.items[i].type)
 
-        for v, t in defn.items:
+        for v in defn.items:
             if self.locals:
                 defn.kind = LDEF
                 self.add_local(v, defn)

strconv.py

@@ -64,7 +64,7 @@ def func_helper(self, o):
     def visit_mypy_file(self, o):
         # Skip implicit definition of __name__.
         if (o.defs and isinstance(o.defs[0], nodes.VarDef) and
-                o.defs[0].items[0][0].name() == '__name__'):
+                o.defs[0].items[0].name() == '__name__'):
             a = [o.defs[1:]]
         else:
             a = [o.defs]
@@ -126,9 +126,9 @@ def visit_type_def(self, o):
 
     def visit_var_def(self, o):
         a = []
-        for n, t in o.items:
+        for n in o.items:
             a.append('Var({})'.format(n.name()))
-            a.append('Type({})'.format(t))
+            a.append('Type({})'.format(n.type))
         if o.init:
             a.append(o.init)
         return self.dump(a, o)

transform.py

@@ -98,8 +98,8 @@ class DyncheckTransformVisitor(TraverserVisitor):
         super().visit_var_def(o)
 
         if o.init is not None:
-            if o.items[0][0].type:
-                t = o.items[0][0].type
+            if o.items[0].type:
+                t = o.items[0].type
             else:
                 t = Any()
             o.init = self.coerce(o.init, t, self.get_type(o.init),

transformtype.py

@@ -79,7 +79,7 @@ class TypeTransformer:
             elif isinstance(d, VarDef):
                 vdef = (VarDef)d
                 defs.extend(self.transform_var_def(vdef))
-                for n, vt in vdef.items:
+                for n in vdef.items:
                     vars.add(n)
 
         # Add accessors for implicitly defined attributes.
@@ -244,7 +244,7 @@ class TypeTransformer:
 
         # Add $x and set$x accessor wrappers for data attributes. These let
         # derived classes redefine a data attribute as a property.
-        for n, vt in o.items:
+        for n in o.items:
             res.extend(self.make_accessors(n))
 
         return res
@@ -366,7 +366,7 @@ class TypeTransformer:
     Node[] generic_accessor_wrappers(self, VarDef vdef):
         """Construct wrapper class methods for attribute accessors."""
         res = <Node> []
-        for n, vt in vdef.items:
+        for n in vdef.items:
             if n.type:
                 t = n.type
             else:
@@ -442,8 +442,8 @@ class TypeTransformer:
         This is added to a generic wrapper class.
         """
         # The type is 'any' since it should behave covariantly in subclasses.
-        return [VarDef([(Var(self.object_member_name(tdef.info)),
-                         Any())], False, None)]
+        return [VarDef([Var(self.object_member_name(tdef.info),
+                            Any())], False, None)]
 
     str object_member_name(self, TypeInfo info):
         if self.tf.is_java:
@@ -513,8 +513,8 @@ class TypeTransformer:
             # Only include a type variable if it introduces a new slot.
             slot = get_tvar_access_path(info, n + 1)[0] - 1
             if slot >= base_slots:
-                defs.append(VarDef([(Var(tvar_slot_name(slot, is_alt)),
-                                     Any())], False, None))
+                defs.append(VarDef([Var(tvar_slot_name(slot, is_alt),
+                                        Any())], False, None))
         return defs
 
     void make_instance_tvar_initializer(self, FuncDef creat):

traverser.py

@@ -50,7 +50,7 @@ def visit_decorator(self, o):
     T visit_var_def(self, VarDef o):
         if o.init is not None:
             o.init.accept(self)
-        for v, t in o.items:
+        for v in o.items:
             self.visit_var(v)
 
     def visit_expression_stmt(self, o):