libv8 6.7.288.46.1 → 7.3.492.27.0beta1

data/vendor/depot_tools/third_party/logilab/astroid/raw_building.py

@@ -19,9 +19,8 @@
 (build_* functions) or from living object (object_build_* functions)
 """
 
-__docformat__ = "restructuredtext en"
-
 import sys
+import os
 from os.path import abspath
 from inspect import (getargspec, isdatadescriptor, isfunction, ismethod,
                      ismethoddescriptor, isclass, isbuiltin, ismodule)
@@ -35,6 +34,8 @@ from astroid.manager import AstroidManager
 MANAGER = AstroidManager()
 
 _CONSTANTS = tuple(CONST_CLS) # the keys of CONST_CLS eg python builtin types
+_JYTHON = os.name == 'java'
+_BUILTINS = vars(six.moves.builtins)
 
 def _io_discrepancy(member):
     # _io module names itself `io`: http://bugs.python.org/issue18602
@@ -48,6 +49,18 @@ def _attach_local_node(parent, node, name):
     node.name = name # needed by add_local_node
     parent.add_local_node(node)
 
+
+def _add_dunder_class(func, member):
+    """Add a __class__ member to the given func node, if we can determine it."""
+    python_cls = member.__class__
+    cls_name = getattr(python_cls, '__name__', None)
+    if not cls_name:
+        return
+    bases = [ancestor.__name__ for ancestor in python_cls.__bases__]
+    ast_klass = build_class(cls_name, bases, python_cls.__doc__)
+    func._instance_attrs['__class__'] = [ast_klass]
+
+
 _marker = object()
 
 def attach_dummy_node(node, name, object=_marker):
@@ -170,6 +183,7 @@ def object_build_methoddescriptor(node, member, localname):
     # and empty argument list
     func.args.args = None
     node.add_local_node(func, localname)
+    _add_dunder_class(func, member)
 
 def _base_class_object_build(node, member, basenames, name=None, localname=None):
     """create astroid for a living class object, with a given set of base names
@@ -196,7 +210,7 @@ def _base_class_object_build(node, member, basenames, name=None, localname=None)
             valnode.object = obj
             valnode.parent = klass
             valnode.lineno = 1
-            klass.instance_attrs[name] = [valnode]
+            klass._instance_attrs[name] = [valnode]
     return klass
 
 
@@ -228,7 +242,7 @@ class InspectBuilder(object):
         except AttributeError:
             # in jython, java modules have no __doc__ (see #109562)
             node = build_module(modname)
-        node.file = node.path = path and abspath(path) or path
+        node.source_file = path and abspath(path) or path
         node.name = modname
         MANAGER.cache_module(node)
         node.package = hasattr(module, '__path__')
@@ -273,7 +287,7 @@ class InspectBuilder(object):
                     continue
                 if member in self._done:
                     class_node = self._done[member]
-                    if not class_node in node.locals.get(name, ()):
+                    if not class_node in node._locals.get(name, ()):
                         node.add_local_node(class_node, name)
                 else:
                     class_node = object_build_class(node, member, name)
@@ -307,7 +321,8 @@ class InspectBuilder(object):
             traceback.print_exc()
             modname = None
         if modname is None:
-            if name in ('__new__', '__subclasshook__'):
+            if (name in ('__new__', '__subclasshook__')
+                    or (name in _BUILTINS and _JYTHON)):
                 # Python 2.5.1 (r251:54863, Sep  1 2010, 22:03:14)
                 # >>> print object.__new__.__module__
                 # None
@@ -315,7 +330,13 @@ class InspectBuilder(object):
             else:
                 attach_dummy_node(node, name, member)
                 return True
-        if {'gtk': 'gtk._gtk'}.get(modname, modname) != self._module.__name__:
+
+        real_name = {
+            'gtk': 'gtk_gtk',
+            '_io': 'io',
+        }.get(modname, modname)
+
+        if real_name != self._module.__name__:
             # check if it sounds valid and then add an import node, else use a
             # dummy node
             try:
@@ -337,13 +358,16 @@ def _astroid_bootstrapping(astroid_builtin=None):
     # this boot strapping is necessary since we need the Const nodes to
     # inspect_build builtins, and then we can proxy Const
     if astroid_builtin is None:
-        from logilab.common.compat import builtins
+        from six.moves import builtins
         astroid_builtin = Astroid_BUILDER.inspect_build(builtins)
 
     for cls, node_cls in CONST_CLS.items():
         if cls is type(None):
             proxy = build_class('NoneType')
             proxy.parent = astroid_builtin
+        elif cls is type(NotImplemented):
+            proxy = build_class('NotImplementedType')
+            proxy.parent = astroid_builtin
         else:
             proxy = astroid_builtin.getattr(cls.__name__)[0]
         if cls in (dict, list, set, tuple):

data/vendor/depot_tools/third_party/logilab/astroid/rebuilder.py

@@ -20,10 +20,10 @@ order to get a single Astroid representation
 """
 
 import sys
+import _ast
 from _ast import (
-    Expr as Discard, Str,
     # binary operators
-    Add, BinOp, Div, FloorDiv, Mod, Mult, Pow, Sub, BitAnd, BitOr, BitXor,
+    Add, Div, FloorDiv, Mod, Mult, Pow, Sub, BitAnd, BitOr, BitXor,
     LShift, RShift,
     # logical operators
     And, Or,
@@ -50,6 +50,9 @@ _BIN_OP_CLASSES = {Add: '+',
                    LShift: '<<',
                    RShift: '>>',
                   }
+if sys.version_info >= (3, 5):
+    from _ast import MatMult
+    _BIN_OP_CLASSES[MatMult] = '@'
 
 _BOOL_OP_CLASSES = {And: 'and',
                     Or: 'or',
@@ -79,19 +82,11 @@ CONST_NAME_TRANSFORMS = {'None':  None,
                         }
 
 REDIRECT = {'arguments': 'Arguments',
-            'Attribute': 'Getattr',
             'comprehension': 'Comprehension',
-            'Call': 'CallFunc',
-            'ClassDef': 'Class',
             "ListCompFor": 'Comprehension',
             "GenExprFor": 'Comprehension',
             'excepthandler': 'ExceptHandler',
-            'Expr': 'Discard',
-            'FunctionDef': 'Function',
-            'GeneratorExp': 'GenExpr',
-            'ImportFrom': 'From',
             'keyword': 'Keyword',
-            'Repr': 'Backquote',
            }
 PY3K = sys.version_info >= (3, 0)
 PY34 = sys.version_info >= (3, 4)
@@ -99,7 +94,7 @@ PY34 = sys.version_info >= (3, 4)
 def _init_set_doc(node, newnode):
     newnode.doc = None
     try:
-        if isinstance(node.body[0], Discard) and isinstance(node.body[0].value, Str):
+        if isinstance(node.body[0], _ast.Expr) and isinstance(node.body[0].value, _ast.Str):
             newnode.doc = node.body[0].value.s
             node.body = node.body[1:]
 
@@ -122,9 +117,21 @@ def _create_yield_node(node, parent, rebuilder, factory):
     newnode = factory()
     _lineno_parent(node, newnode, parent)
     if node.value is not None:
-        newnode.value = rebuilder.visit(node.value, newnode)
+        newnode.value = rebuilder.visit(node.value, newnode, None)
     return newnode
 
+def _visit_or_none(node, attr, visitor, parent, assign_ctx, visit='visit',
+                   **kws):
+    """If the given node has an attribute, visits the attribute, and
+    otherwise returns None.
+
+    """
+    value = getattr(node, attr, None)
+    if value:
+        return getattr(visitor, visit)(value, parent, assign_ctx, **kws)
+    else:
+        return None
+
 
 class TreeRebuilder(object):
     """Rebuilds the _ast tree to become an Astroid tree"""
@@ -133,10 +140,9 @@ class TreeRebuilder(object):
         self._manager = manager
         self.asscontext = None
         self._global_names = []
-        self._from_nodes = []
+        self._import_from_nodes = []
         self._delayed_assattr = []
         self._visit_meths = {}
-        self._transform = manager.transform
         self._peepholer = astpeephole.ASTPeepholeOptimizer()
 
     def visit_module(self, node, modname, modpath, package):
@@ -146,10 +152,10 @@ class TreeRebuilder(object):
         newnode.parent = None
         _init_set_doc(node, newnode)
         newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.file = newnode.path = modpath
-        return self._transform(newnode)
+        newnode.source_file = modpath
+        return newnode
 
-    def visit(self, node, parent):
+    def visit(self, node, parent, assign_ctx=None):
         cls = node.__class__
         if cls in self._visit_meths:
             visit_method = self._visit_meths[cls]
@@ -158,7 +164,7 @@ class TreeRebuilder(object):
             visit_name = 'visit_' + REDIRECT.get(cls_name, cls_name).lower()
             visit_method = getattr(self, visit_name)
             self._visit_meths[cls] = visit_method
-        return self._transform(visit_method(node, parent))
+        return visit_method(node, parent, assign_ctx)
 
     def _save_assignment(self, node, name=None):
         """save assignement situation since node.parent is not available yet"""
@@ -167,15 +173,14 @@ class TreeRebuilder(object):
         else:
             node.parent.set_local(node.name, node)
 
-
-    def visit_arguments(self, node, parent):
+    def visit_arguments(self, node, parent, assign_ctx=None):
         """visit a Arguments node by returning a fresh instance of it"""
         newnode = new.Arguments()
         newnode.parent = parent
-        self.asscontext = "Ass"
-        newnode.args = [self.visit(child, newnode) for child in node.args]
-        self.asscontext = None
-        newnode.defaults = [self.visit(child, newnode) for child in node.defaults]
+        newnode.args = [self.visit(child, newnode, "Assign")
+                        for child in node.args]
+        newnode.defaults = [self.visit(child, newnode, assign_ctx)
+                            for child in node.defaults]
         newnode.kwonlyargs = []
         newnode.kw_defaults = []
         vararg, kwarg = node.vararg, node.kwarg
@@ -185,21 +190,21 @@ class TreeRebuilder(object):
             if PY34:
                 if vararg.annotation:
                     newnode.varargannotation = self.visit(vararg.annotation,
-                                                          newnode)
+                                                          newnode, assign_ctx)
                 vararg = vararg.arg
             elif PY3K and node.varargannotation:
                 newnode.varargannotation = self.visit(node.varargannotation,
-                                                      newnode)
+                                                      newnode, assign_ctx)
         if kwarg:
             if PY34:
                 if kwarg.annotation:
                     newnode.kwargannotation = self.visit(kwarg.annotation,
-                                                         newnode)
+                                                         newnode, assign_ctx)
                 kwarg = kwarg.arg
             elif PY3K:
                 if node.kwargannotation:
                     newnode.kwargannotation = self.visit(node.kwargannotation,
-                                                         newnode)
+                                                         newnode, assign_ctx)
         newnode.vararg = vararg
         newnode.kwarg = kwarg
         # save argument names in locals:
@@ -209,81 +214,59 @@ class TreeRebuilder(object):
             newnode.parent.set_local(kwarg, newnode)
         return newnode
 
-    def visit_assattr(self, node, parent):
+    def visit_assignattr(self, node, parent, assign_ctx=None):
         """visit a AssAttr node by returning a fresh instance of it"""
-        assc, self.asscontext = self.asscontext, None
-        newnode = new.AssAttr()
+        newnode = new.AssignAttr()
         _lineno_parent(node, newnode, parent)
-        newnode.expr = self.visit(node.expr, newnode)
-        self.asscontext = assc
+        newnode.expr = self.visit(node.expr, newnode, assign_ctx)
         self._delayed_assattr.append(newnode)
         return newnode
 
-    def visit_assert(self, node, parent):
+    def visit_assert(self, node, parent, assign_ctx=None):
         """visit a Assert node by returning a fresh instance of it"""
         newnode = new.Assert()
         _lineno_parent(node, newnode, parent)
-        newnode.test = self.visit(node.test, newnode)
+        newnode.test = self.visit(node.test, newnode, assign_ctx)
         if node.msg is not None:
-            newnode.fail = self.visit(node.msg, newnode)
+            newnode.fail = self.visit(node.msg, newnode, assign_ctx)
         return newnode
 
-    def visit_assign(self, node, parent):
+    def visit_assign(self, node, parent, assign_ctx=None):
         """visit a Assign node by returning a fresh instance of it"""
         newnode = new.Assign()
         _lineno_parent(node, newnode, parent)
-        self.asscontext = "Ass"
-        newnode.targets = [self.visit(child, newnode) for child in node.targets]
-        self.asscontext = None
-        newnode.value = self.visit(node.value, newnode)
-        # set some function or metaclass infos  XXX explain ?
-        klass = newnode.parent.frame()
-        if (isinstance(klass, new.Class)
-                and isinstance(newnode.value, new.CallFunc)
-                and isinstance(newnode.value.func, new.Name)):
-            func_name = newnode.value.func.name
-            for ass_node in newnode.targets:
-                try:
-                    meth = klass[ass_node.name]
-                    if isinstance(meth, new.Function):
-                        if func_name in ('classmethod', 'staticmethod'):
-                            meth.type = func_name
-                        elif func_name == 'classproperty': # see lgc.decorators
-                            meth.type = 'classmethod'
-                        meth.extra_decorators.append(newnode.value)
-                except (AttributeError, KeyError):
-                    continue
-        return newnode
-
-    def visit_assname(self, node, parent, node_name=None):
+        newnode.targets = [self.visit(child, newnode, "Assign")
+                           for child in node.targets]
+        newnode.value = self.visit(node.value, newnode, None)
+        return newnode
+
+    def visit_assignname(self, node, parent, assign_ctx=None, node_name=None):
         '''visit a node and return a AssName node'''
-        newnode = new.AssName()
+        newnode = new.AssignName()
         _set_infos(node, newnode, parent)
         newnode.name = node_name
         self._save_assignment(newnode)
         return newnode
 
-    def visit_augassign(self, node, parent):
+    def visit_augassign(self, node, parent, assign_ctx=None):
         """visit a AugAssign node by returning a fresh instance of it"""
         newnode = new.AugAssign()
         _lineno_parent(node, newnode, parent)
         newnode.op = _BIN_OP_CLASSES[node.op.__class__] + "="
-        self.asscontext = "Ass"
-        newnode.target = self.visit(node.target, newnode)
-        self.asscontext = None
-        newnode.value = self.visit(node.value, newnode)
+        newnode.target = self.visit(node.target, newnode, "Assign")
+        newnode.value = self.visit(node.value, newnode, None)
         return newnode
 
-    def visit_backquote(self, node, parent):
+    def visit_repr(self, node, parent, assign_ctx=None):
         """visit a Backquote node by returning a fresh instance of it"""
-        newnode = new.Backquote()
+        newnode = new.Repr()
         _lineno_parent(node, newnode, parent)
-        newnode.value = self.visit(node.value, newnode)
+        newnode.value = self.visit(node.value, newnode, assign_ctx)
         return newnode
 
-    def visit_binop(self, node, parent):
+    def visit_binop(self, node, parent, assign_ctx=None):
         """visit a BinOp node by returning a fresh instance of it"""
-        if isinstance(node.left, BinOp) and self._manager.optimize_ast:
+        if isinstance(node.left, _ast.BinOp) and self._manager.optimize_ast:
             # Optimize BinOp operations in order to remove
             # redundant recursion. For instance, if the
             # following code is parsed in order to obtain
@@ -296,264 +279,299 @@ class TreeRebuilder(object):
             # problem for the correctness of the program).
             #
             # ("a" + "b" + # one thousand more + "c")
-            newnode = self._peepholer.optimize_binop(node)
-            if newnode:
-                _lineno_parent(node, newnode, parent)
-                return newnode
+            optimized = self._peepholer.optimize_binop(node)
+            if optimized:
+                _lineno_parent(node, optimized, parent)
+                return optimized
 
         newnode = new.BinOp()
         _lineno_parent(node, newnode, parent)
-        newnode.left = self.visit(node.left, newnode)
-        newnode.right = self.visit(node.right, newnode)
+        newnode.left = self.visit(node.left, newnode, assign_ctx)
+        newnode.right = self.visit(node.right, newnode, assign_ctx)
         newnode.op = _BIN_OP_CLASSES[node.op.__class__]
         return newnode
 
-    def visit_boolop(self, node, parent):
+    def visit_boolop(self, node, parent, assign_ctx=None):
         """visit a BoolOp node by returning a fresh instance of it"""
         newnode = new.BoolOp()
         _lineno_parent(node, newnode, parent)
-        newnode.values = [self.visit(child, newnode) for child in node.values]
+        newnode.values = [self.visit(child, newnode, assign_ctx)
+                          for child in node.values]
         newnode.op = _BOOL_OP_CLASSES[node.op.__class__]
         return newnode
 
-    def visit_break(self, node, parent):
+    def visit_break(self, node, parent, assign_ctx=None):
         """visit a Break node by returning a fresh instance of it"""
         newnode = new.Break()
         _set_infos(node, newnode, parent)
         return newnode
 
-    def visit_callfunc(self, node, parent):
+    def visit_call(self, node, parent, assign_ctx=None):
         """visit a CallFunc node by returning a fresh instance of it"""
-        newnode = new.CallFunc()
-        _lineno_parent(node, newnode, parent)
-        newnode.func = self.visit(node.func, newnode)
-        newnode.args = [self.visit(child, newnode) for child in node.args]
-        if node.starargs is not None:
-            newnode.starargs = self.visit(node.starargs, newnode)
-        if node.kwargs is not None:
-            newnode.kwargs = self.visit(node.kwargs, newnode)
-        for child in node.keywords:
-            newnode.args.append(self.visit(child, newnode))
+        newnode = new.Call()
+        _lineno_parent(node, newnode, parent)
+        newnode.func = self.visit(node.func, newnode, assign_ctx)
+        args = [self.visit(child, newnode, assign_ctx)
+                for child in node.args]
+
+        starargs = _visit_or_none(node, 'starargs', self, newnode,
+                                  assign_ctx)
+        kwargs = _visit_or_none(node, 'kwargs', self, newnode,
+                                assign_ctx)
+        keywords = None
+        if node.keywords:
+            keywords = [self.visit(child, newnode, assign_ctx)
+                        for child in node.keywords]
+
+        if starargs:
+            new_starargs = new.Starred()
+            new_starargs.col_offset = starargs.col_offset
+            new_starargs.lineno = starargs.lineno
+            new_starargs.parent = starargs.parent
+            new_starargs.value = starargs
+            args.append(new_starargs)
+        if kwargs:
+            new_kwargs = new.Keyword()
+            new_kwargs.arg = None
+            new_kwargs.col_offset = kwargs.col_offset
+            new_kwargs.lineno = kwargs.lineno
+            new_kwargs.parent = kwargs.parent
+            new_kwargs.value = kwargs
+            if keywords:
+                keywords.append(new_kwargs)
+            else:
+                keywords = [new_kwargs]
+
+        newnode.args = args
+        newnode.keywords = keywords
         return newnode
 
-    def visit_class(self, node, parent):
+    def visit_classdef(self, node, parent, assign_ctx=None):
         """visit a Class node to become astroid"""
-        newnode = new.Class(node.name, None)
+        newnode = new.ClassDef(node.name, None)
         _lineno_parent(node, newnode, parent)
         _init_set_doc(node, newnode)
-        newnode.bases = [self.visit(child, newnode) for child in node.bases]
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        if 'decorator_list' in node._fields and node.decorator_list:# py >= 2.6
-            newnode.decorators = self.visit_decorators(node, newnode)
+        newnode.bases = [self.visit(child, newnode, assign_ctx)
+                         for child in node.bases]
+        newnode.body = [self.visit(child, newnode, assign_ctx)
+                        for child in node.body]
+        if node.decorator_list:
+            newnode.decorators = self.visit_decorators(node, newnode, assign_ctx)
         newnode.parent.frame().set_local(newnode.name, newnode)
         return newnode
 
-    def visit_const(self, node, parent):
+    def visit_const(self, node, parent, assign_ctx=None):
         """visit a Const node by returning a fresh instance of it"""
         newnode = new.Const(node.value)
         _set_infos(node, newnode, parent)
         return newnode
 
-    def visit_continue(self, node, parent):
+    def visit_continue(self, node, parent, assign_ctx=None):
         """visit a Continue node by returning a fresh instance of it"""
         newnode = new.Continue()
         _set_infos(node, newnode, parent)
         return newnode
 
-    def visit_compare(self, node, parent):
+    def visit_compare(self, node, parent, assign_ctx=None):
         """visit a Compare node by returning a fresh instance of it"""
         newnode = new.Compare()
         _lineno_parent(node, newnode, parent)
-        newnode.left = self.visit(node.left, newnode)
-        newnode.ops = [(_CMP_OP_CLASSES[op.__class__], self.visit(expr, newnode))
+        newnode.left = self.visit(node.left, newnode, assign_ctx)
+        newnode.ops = [(_CMP_OP_CLASSES[op.__class__], self.visit(expr, newnode, assign_ctx))
                        for (op, expr) in zip(node.ops, node.comparators)]
         return newnode
 
-    def visit_comprehension(self, node, parent):
+    def visit_comprehension(self, node, parent, assign_ctx=None):
         """visit a Comprehension node by returning a fresh instance of it"""
         newnode = new.Comprehension()
         newnode.parent = parent
-        self.asscontext = "Ass"
-        newnode.target = self.visit(node.target, newnode)
-        self.asscontext = None
-        newnode.iter = self.visit(node.iter, newnode)
-        newnode.ifs = [self.visit(child, newnode) for child in node.ifs]
+        newnode.target = self.visit(node.target, newnode, 'Assign')
+        newnode.iter = self.visit(node.iter, newnode, None)
+        newnode.ifs = [self.visit(child, newnode, None)
+                       for child in node.ifs]
         return newnode
 
-    def visit_decorators(self, node, parent):
+    def visit_decorators(self, node, parent, assign_ctx=None):
         """visit a Decorators node by returning a fresh instance of it"""
         # /!\ node is actually a _ast.Function node while
         # parent is a astroid.nodes.Function node
         newnode = new.Decorators()
         _lineno_parent(node, newnode, parent)
-        if 'decorators' in node._fields: # py < 2.6, i.e. 2.5
-            decorators = node.decorators
-        else:
-            decorators = node.decorator_list
-        newnode.nodes = [self.visit(child, newnode) for child in decorators]
+        decorators = node.decorator_list
+        newnode.nodes = [self.visit(child, newnode, assign_ctx)
+                         for child in decorators]
         return newnode
 
-    def visit_delete(self, node, parent):
+    def visit_delete(self, node, parent, assign_ctx=None):
         """visit a Delete node by returning a fresh instance of it"""
         newnode = new.Delete()
         _lineno_parent(node, newnode, parent)
-        self.asscontext = "Del"
-        newnode.targets = [self.visit(child, newnode) for child in node.targets]
-        self.asscontext = None
+        newnode.targets = [self.visit(child, newnode, 'Del')
+                           for child in node.targets]
         return newnode
 
-    def visit_dict(self, node, parent):
+    def _visit_dict_items(self, node, parent, newnode, assign_ctx):
+        for key, value in zip(node.keys, node.values):
+            rebuilt_value = self.visit(value, newnode, assign_ctx)
+            if not key:
+                # Python 3.5 and extended unpacking
+                rebuilt_key = new.DictUnpack()
+                rebuilt_key.lineno = rebuilt_value.lineno
+                rebuilt_key.col_offset = rebuilt_value.col_offset
+                rebuilt_key.parent = rebuilt_value.parent
+            else:
+                rebuilt_key = self.visit(key, newnode, assign_ctx)
+            yield rebuilt_key, rebuilt_value
+
+    def visit_dict(self, node, parent, assign_ctx=None):
         """visit a Dict node by returning a fresh instance of it"""
         newnode = new.Dict()
         _lineno_parent(node, newnode, parent)
-        newnode.items = [(self.visit(key, newnode), self.visit(value, newnode))
-                         for key, value in zip(node.keys, node.values)]
+        newnode.items = list(self._visit_dict_items(node, parent, newnode, assign_ctx))
         return newnode
 
-    def visit_dictcomp(self, node, parent):
+    def visit_dictcomp(self, node, parent, assign_ctx=None):
         """visit a DictComp node by returning a fresh instance of it"""
         newnode = new.DictComp()
         _lineno_parent(node, newnode, parent)
-        newnode.key = self.visit(node.key, newnode)
-        newnode.value = self.visit(node.value, newnode)
-        newnode.generators = [self.visit(child, newnode)
+        newnode.key = self.visit(node.key, newnode, assign_ctx)
+        newnode.value = self.visit(node.value, newnode, assign_ctx)
+        newnode.generators = [self.visit(child, newnode, assign_ctx)
                               for child in node.generators]
         return newnode
 
-    def visit_discard(self, node, parent):
+    def visit_expr(self, node, parent, assign_ctx=None):
         """visit a Discard node by returning a fresh instance of it"""
-        newnode = new.Discard()
+        newnode = new.Expr()
         _lineno_parent(node, newnode, parent)
-        newnode.value = self.visit(node.value, newnode)
+        newnode.value = self.visit(node.value, newnode, assign_ctx)
         return newnode
 
-    def visit_ellipsis(self, node, parent):
+    def visit_ellipsis(self, node, parent, assign_ctx=None):
         """visit an Ellipsis node by returning a fresh instance of it"""
         newnode = new.Ellipsis()
         _set_infos(node, newnode, parent)
         return newnode
 
-    def visit_emptynode(self, node, parent):
+    def visit_emptynode(self, node, parent, assign_ctx=None):
         """visit an EmptyNode node by returning a fresh instance of it"""
         newnode = new.EmptyNode()
         _set_infos(node, newnode, parent)
         return newnode
 
-    def visit_excepthandler(self, node, parent):
+    def visit_excepthandler(self, node, parent, assign_ctx=None):
         """visit an ExceptHandler node by returning a fresh instance of it"""
         newnode = new.ExceptHandler()
         _lineno_parent(node, newnode, parent)
         if node.type is not None:
-            newnode.type = self.visit(node.type, newnode)
+            newnode.type = self.visit(node.type, newnode, assign_ctx)
         if node.name is not None:
             # /!\ node.name can be a tuple
-            self.asscontext = "Ass"
-            newnode.name = self.visit(node.name, newnode)
-            self.asscontext = None
-        newnode.body = [self.visit(child, newnode) for child in node.body]
+            newnode.name = self.visit(node.name, newnode, 'Assign')
+        newnode.body = [self.visit(child, newnode, None)
+                        for child in node.body]
         return newnode
 
-    def visit_exec(self, node, parent):
+    def visit_exec(self, node, parent, assign_ctx=None):
         """visit an Exec node by returning a fresh instance of it"""
         newnode = new.Exec()
         _lineno_parent(node, newnode, parent)
         newnode.expr = self.visit(node.body, newnode)
         if node.globals is not None:
-            newnode.globals = self.visit(node.globals, newnode)
+            newnode.globals = self.visit(node.globals, newnode,
+                                         assign_ctx)
         if node.locals is not None:
-            newnode.locals = self.visit(node.locals, newnode)
+            newnode.locals = self.visit(node.locals, newnode,
+                                        assign_ctx)
         return newnode
 
-    def visit_extslice(self, node, parent):
+    def visit_extslice(self, node, parent, assign_ctx=None):
         """visit an ExtSlice node by returning a fresh instance of it"""
         newnode = new.ExtSlice()
         newnode.parent = parent
-        newnode.dims = [self.visit(dim, newnode) for dim in node.dims]
+        newnode.dims = [self.visit(dim, newnode, assign_ctx)
+                        for dim in node.dims]
         return newnode
 
-    def visit_for(self, node, parent):
+    def _visit_for(self, cls, node, parent, assign_ctx=None):
         """visit a For node by returning a fresh instance of it"""
-        newnode = new.For()
+        newnode = cls()
         _lineno_parent(node, newnode, parent)
-        self.asscontext = "Ass"
-        newnode.target = self.visit(node.target, newnode)
-        self.asscontext = None
-        newnode.iter = self.visit(node.iter, newnode)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.orelse = [self.visit(child, newnode) for child in node.orelse]
+        newnode.target = self.visit(node.target, newnode, "Assign")
+        newnode.iter = self.visit(node.iter, newnode, None)
+        newnode.body = [self.visit(child, newnode, None)
+                        for child in node.body]
+        newnode.orelse = [self.visit(child, newnode, None)
+                          for child in node.orelse]
         return newnode
 
-    def visit_from(self, node, parent):
+    def visit_for(self, node, parent, assign_ctx=None):
+        return self._visit_for(new.For, node, parent,
+                               assign_ctx=assign_ctx)
+    def visit_importfrom(self, node, parent, assign_ctx=None):
         """visit a From node by returning a fresh instance of it"""
         names = [(alias.name, alias.asname) for alias in node.names]
-        newnode = new.From(node.module or '', names, node.level or None)
+        newnode = new.ImportFrom(node.module or '', names, node.level or None)
         _set_infos(node, newnode, parent)
         # store From names to add them to locals after building
-        self._from_nodes.append(newnode)
+        self._import_from_nodes.append(newnode)
         return newnode
 
-    def visit_function(self, node, parent):
-        """visit an Function node to become astroid"""
+    def _visit_functiondef(self, cls, node, parent, assign_ctx=None):
+        """visit an FunctionDef node to become astroid"""
         self._global_names.append({})
-        newnode = new.Function(node.name, None)
+        newnode = cls(node.name, None)
         _lineno_parent(node, newnode, parent)
         _init_set_doc(node, newnode)
-        newnode.args = self.visit(node.args, newnode)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        if 'decorators' in node._fields: # py < 2.6
-            attr = 'decorators'
-        else:
-            attr = 'decorator_list'
-        decorators = getattr(node, attr)
+        newnode.args = self.visit(node.args, newnode, assign_ctx)
+        newnode.body = [self.visit(child, newnode, assign_ctx)
+                        for child in node.body]
+        decorators = node.decorator_list
         if decorators:
-            newnode.decorators = self.visit_decorators(node, newnode)
+            newnode.decorators = self.visit_decorators(
+                    node, newnode, assign_ctx)
         if PY3K and node.returns:
-            newnode.returns = self.visit(node.returns, newnode)
+            newnode.returns = self.visit(node.returns, newnode,
+                                         assign_ctx)
         self._global_names.pop()
         frame = newnode.parent.frame()
-        if isinstance(frame, new.Class):
-            if newnode.name == '__new__':
-                newnode._type = 'classmethod'
-            else:
-                newnode._type = 'method'
-        if newnode.decorators is not None:
-            for decorator_expr in newnode.decorators.nodes:
-                if isinstance(decorator_expr, new.Name):
-                    if decorator_expr.name in ('classmethod', 'staticmethod'):
-                        newnode._type = decorator_expr.name
-                    elif decorator_expr.name == 'classproperty':
-                        newnode._type = 'classmethod'
         frame.set_local(newnode.name, newnode)
         return newnode
 
-    def visit_genexpr(self, node, parent):
+    def visit_functiondef(self, node, parent, assign_ctx=None):
+        return self._visit_functiondef(new.FunctionDef, node, parent,
+                                       assign_ctx=assign_ctx)
+
+    def visit_generatorexp(self, node, parent, assign_ctx=None):
         """visit a GenExpr node by returning a fresh instance of it"""
-        newnode = new.GenExpr()
+        newnode = new.GeneratorExp()
         _lineno_parent(node, newnode, parent)
-        newnode.elt = self.visit(node.elt, newnode)
-        newnode.generators = [self.visit(child, newnode) for child in node.generators]
+        newnode.elt = self.visit(node.elt, newnode, assign_ctx)
+        newnode.generators = [self.visit(child, newnode, assign_ctx)
+                              for child in node.generators]
         return newnode
 
-    def visit_getattr(self, node, parent):
+    def visit_attribute(self, node, parent, assign_ctx=None):
         """visit a Getattr node by returning a fresh instance of it"""
-        if self.asscontext == "Del":
+        # pylint: disable=redefined-variable-type
+        if assign_ctx == "Del":
             # FIXME : maybe we should reintroduce and visit_delattr ?
             # for instance, deactivating asscontext
             newnode = new.DelAttr()
-        elif self.asscontext == "Ass":
+        elif assign_ctx == "Assign":
             # FIXME : maybe we should call visit_assattr ?
-            newnode = new.AssAttr()
-            self._delayed_assattr.append(newnode)
+            # Prohibit a local save if we are in an ExceptHandler.
+            newnode = new.AssignAttr()
+            if not isinstance(parent, new.ExceptHandler):
+                self._delayed_assattr.append(newnode)
         else:
-            newnode = new.Getattr()
+            newnode = new.Attribute()
         _lineno_parent(node, newnode, parent)
-        asscontext, self.asscontext = self.asscontext, None
-        newnode.expr = self.visit(node.value, newnode)
-        self.asscontext = asscontext
+        newnode.expr = self.visit(node.value, newnode, None)
         newnode.attrname = node.attr
         return newnode
 
-    def visit_global(self, node, parent):
+    def visit_global(self, node, parent, assign_ctx=None):
         """visit an Global node to become astroid"""
         newnode = new.Global(node.names)
         _set_infos(node, newnode, parent)
@@ -562,25 +580,27 @@ class TreeRebuilder(object):
                 self._global_names[-1].setdefault(name, []).append(newnode)
         return newnode
 
-    def visit_if(self, node, parent):
+    def visit_if(self, node, parent, assign_ctx=None):
         """visit a If node by returning a fresh instance of it"""
         newnode = new.If()
         _lineno_parent(node, newnode, parent)
-        newnode.test = self.visit(node.test, newnode)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.orelse = [self.visit(child, newnode) for child in node.orelse]
+        newnode.test = self.visit(node.test, newnode, assign_ctx)
+        newnode.body = [self.visit(child, newnode, assign_ctx)
+                        for child in node.body]
+        newnode.orelse = [self.visit(child, newnode, assign_ctx)
+                          for child in node.orelse]
         return newnode
 
-    def visit_ifexp(self, node, parent):
+    def visit_ifexp(self, node, parent, assign_ctx=None):
         """visit a IfExp node by returning a fresh instance of it"""
         newnode = new.IfExp()
         _lineno_parent(node, newnode, parent)
-        newnode.test = self.visit(node.test, newnode)
-        newnode.body = self.visit(node.body, newnode)
-        newnode.orelse = self.visit(node.orelse, newnode)
+        newnode.test = self.visit(node.test, newnode, assign_ctx)
+        newnode.body = self.visit(node.body, newnode, assign_ctx)
+        newnode.orelse = self.visit(node.orelse, newnode, assign_ctx)
         return newnode
 
-    def visit_import(self, node, parent):
+    def visit_import(self, node, parent, assign_ctx=None):
         """visit a Import node by returning a fresh instance of it"""
         newnode = new.Import()
         _set_infos(node, newnode, parent)
@@ -591,53 +611,54 @@ class TreeRebuilder(object):
             newnode.parent.set_local(name.split('.')[0], newnode)
         return newnode
 
-    def visit_index(self, node, parent):
+    def visit_index(self, node, parent, assign_ctx=None):
         """visit a Index node by returning a fresh instance of it"""
         newnode = new.Index()
         newnode.parent = parent
-        newnode.value = self.visit(node.value, newnode)
+        newnode.value = self.visit(node.value, newnode, assign_ctx)
         return newnode
 
-    def visit_keyword(self, node, parent):
+    def visit_keyword(self, node, parent, assign_ctx=None):
         """visit a Keyword node by returning a fresh instance of it"""
         newnode = new.Keyword()
         newnode.parent = parent
         newnode.arg = node.arg
-        newnode.value = self.visit(node.value, newnode)
+        newnode.value = self.visit(node.value, newnode, assign_ctx)
         return newnode
 
-    def visit_lambda(self, node, parent):
+    def visit_lambda(self, node, parent, assign_ctx=None):
         """visit a Lambda node by returning a fresh instance of it"""
         newnode = new.Lambda()
         _lineno_parent(node, newnode, parent)
-        newnode.args = self.visit(node.args, newnode)
-        newnode.body = self.visit(node.body, newnode)
+        newnode.args = self.visit(node.args, newnode, assign_ctx)
+        newnode.body = self.visit(node.body, newnode, assign_ctx)
         return newnode
 
-    def visit_list(self, node, parent):
+    def visit_list(self, node, parent, assign_ctx=None):
         """visit a List node by returning a fresh instance of it"""
         newnode = new.List()
         _lineno_parent(node, newnode, parent)
-        newnode.elts = [self.visit(child, newnode) for child in node.elts]
+        newnode.elts = [self.visit(child, newnode, assign_ctx)
+                        for child in node.elts]
         return newnode
 
-    def visit_listcomp(self, node, parent):
+    def visit_listcomp(self, node, parent, assign_ctx=None):
         """visit a ListComp node by returning a fresh instance of it"""
         newnode = new.ListComp()
         _lineno_parent(node, newnode, parent)
-        newnode.elt = self.visit(node.elt, newnode)
-        newnode.generators = [self.visit(child, newnode)
+        newnode.elt = self.visit(node.elt, newnode, assign_ctx)
+        newnode.generators = [self.visit(child, newnode, assign_ctx)
                               for child in node.generators]
         return newnode
 
-    def visit_name(self, node, parent):
+    def visit_name(self, node, parent, assign_ctx=None):
         """visit a Name node by returning a fresh instance of it"""
         # True and False can be assigned to something in py2x, so we have to
         # check first the asscontext
-        if self.asscontext == "Del":
+        # pylint: disable=redefined-variable-type
+        if assign_ctx == "Del":
             newnode = new.DelName()
-        elif self.asscontext is not None: # Ass
-            assert self.asscontext == "Ass"
+        elif assign_ctx is not None: # Ass
             newnode = new.AssName()
         elif node.id in CONST_NAME_TRANSFORMS:
             newnode = new.Const(CONST_NAME_TRANSFORMS[node.id])
@@ -648,279 +669,321 @@ class TreeRebuilder(object):
         _lineno_parent(node, newnode, parent)
         newnode.name = node.id
         # XXX REMOVE me :
-        if self.asscontext in ('Del', 'Ass'): # 'Aug' ??
+        if assign_ctx in ('Del', 'Assign'): # 'Aug' ??
             self._save_assignment(newnode)
         return newnode
 
-    def visit_bytes(self, node, parent):
+    def visit_bytes(self, node, parent, assign_ctx=None):
         """visit a Bytes node by returning a fresh instance of Const"""
         newnode = new.Const(node.s)
         _set_infos(node, newnode, parent)
         return newnode
 
-    def visit_num(self, node, parent):
+    def visit_num(self, node, parent, assign_ctx=None):
         """visit a Num node by returning a fresh instance of Const"""
         newnode = new.Const(node.n)
         _set_infos(node, newnode, parent)
         return newnode
 
-    def visit_pass(self, node, parent):
+    def visit_pass(self, node, parent, assign_ctx=None):
         """visit a Pass node by returning a fresh instance of it"""
         newnode = new.Pass()
         _set_infos(node, newnode, parent)
         return newnode
 
-    def visit_str(self, node, parent):
+    def visit_str(self, node, parent, assign_ctx=None):
         """visit a Str node by returning a fresh instance of Const"""
         newnode = new.Const(node.s)
         _set_infos(node, newnode, parent)
         return newnode
 
-    def visit_print(self, node, parent):
+    def visit_print(self, node, parent, assign_ctx=None):
         """visit a Print node by returning a fresh instance of it"""
         newnode = new.Print()
         _lineno_parent(node, newnode, parent)
         newnode.nl = node.nl
         if node.dest is not None:
-            newnode.dest = self.visit(node.dest, newnode)
-        newnode.values = [self.visit(child, newnode) for child in node.values]
+            newnode.dest = self.visit(node.dest, newnode, assign_ctx)
+        newnode.values = [self.visit(child, newnode, assign_ctx)
+                          for child in node.values]
         return newnode
 
-    def visit_raise(self, node, parent):
+    def visit_raise(self, node, parent, assign_ctx=None):
         """visit a Raise node by returning a fresh instance of it"""
         newnode = new.Raise()
         _lineno_parent(node, newnode, parent)
         if node.type is not None:
-            newnode.exc = self.visit(node.type, newnode)
+            newnode.exc = self.visit(node.type, newnode, assign_ctx)
         if node.inst is not None:
-            newnode.inst = self.visit(node.inst, newnode)
+            newnode.inst = self.visit(node.inst, newnode, assign_ctx)
         if node.tback is not None:
-            newnode.tback = self.visit(node.tback, newnode)
+            newnode.tback = self.visit(node.tback, newnode, assign_ctx)
         return newnode
 
-    def visit_return(self, node, parent):
+    def visit_return(self, node, parent, assign_ctx=None):
         """visit a Return node by returning a fresh instance of it"""
         newnode = new.Return()
         _lineno_parent(node, newnode, parent)
         if node.value is not None:
-            newnode.value = self.visit(node.value, newnode)
+            newnode.value = self.visit(node.value, newnode, assign_ctx)
         return newnode
 
-    def visit_set(self, node, parent):
+    def visit_set(self, node, parent, assign_ctx=None):
         """visit a Set node by returning a fresh instance of it"""
         newnode = new.Set()
         _lineno_parent(node, newnode, parent)
-        newnode.elts = [self.visit(child, newnode) for child in node.elts]
+        newnode.elts = [self.visit(child, newnode, assign_ctx)
+                        for child in node.elts]
         return newnode
 
-    def visit_setcomp(self, node, parent):
+    def visit_setcomp(self, node, parent, assign_ctx=None):
         """visit a SetComp node by returning a fresh instance of it"""
         newnode = new.SetComp()
         _lineno_parent(node, newnode, parent)
-        newnode.elt = self.visit(node.elt, newnode)
-        newnode.generators = [self.visit(child, newnode)
+        newnode.elt = self.visit(node.elt, newnode, assign_ctx)
+        newnode.generators = [self.visit(child, newnode, assign_ctx)
                               for child in node.generators]
         return newnode
 
-    def visit_slice(self, node, parent):
+    def visit_slice(self, node, parent, assign_ctx=None):
         """visit a Slice node by returning a fresh instance of it"""
         newnode = new.Slice()
         newnode.parent = parent
         if node.lower is not None:
-            newnode.lower = self.visit(node.lower, newnode)
+            newnode.lower = self.visit(node.lower, newnode, assign_ctx)
         if node.upper is not None:
-            newnode.upper = self.visit(node.upper, newnode)
+            newnode.upper = self.visit(node.upper, newnode, assign_ctx)
         if node.step is not None:
-            newnode.step = self.visit(node.step, newnode)
+            newnode.step = self.visit(node.step, newnode, assign_ctx)
         return newnode
 
-    def visit_subscript(self, node, parent):
+    def visit_subscript(self, node, parent, assign_ctx=None):
         """visit a Subscript node by returning a fresh instance of it"""
         newnode = new.Subscript()
         _lineno_parent(node, newnode, parent)
-        subcontext, self.asscontext = self.asscontext, None
-        newnode.value = self.visit(node.value, newnode)
-        newnode.slice = self.visit(node.slice, newnode)
-        self.asscontext = subcontext
+        newnode.value = self.visit(node.value, newnode, None)
+        newnode.slice = self.visit(node.slice, newnode, None)
         return newnode
 
-    def visit_tryexcept(self, node, parent):
+    def visit_tryexcept(self, node, parent, assign_ctx=None):
         """visit a TryExcept node by returning a fresh instance of it"""
         newnode = new.TryExcept()
         _lineno_parent(node, newnode, parent)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.handlers = [self.visit(child, newnode) for child in node.handlers]
-        newnode.orelse = [self.visit(child, newnode) for child in node.orelse]
+        newnode.body = [self.visit(child, newnode, assign_ctx)
+                        for child in node.body]
+        newnode.handlers = [self.visit(child, newnode, assign_ctx)
+                            for child in node.handlers]
+        newnode.orelse = [self.visit(child, newnode, assign_ctx)
+                          for child in node.orelse]
         return newnode
 
-    def visit_tryfinally(self, node, parent):
+    def visit_tryfinally(self, node, parent, assign_ctx=None):
         """visit a TryFinally node by returning a fresh instance of it"""
         newnode = new.TryFinally()
         _lineno_parent(node, newnode, parent)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.finalbody = [self.visit(n, newnode) for n in node.finalbody]
+        newnode.body = [self.visit(child, newnode, assign_ctx)
+                        for child in node.body]
+        newnode.finalbody = [self.visit(n, newnode, assign_ctx)
+                             for n in node.finalbody]
         return newnode
 
-    def visit_tuple(self, node, parent):
+    def visit_tuple(self, node, parent, assign_ctx=None):
         """visit a Tuple node by returning a fresh instance of it"""
         newnode = new.Tuple()
         _lineno_parent(node, newnode, parent)
-        newnode.elts = [self.visit(child, newnode) for child in node.elts]
+        newnode.elts = [self.visit(child, newnode, assign_ctx)
+                        for child in node.elts]
         return newnode
 
-    def visit_unaryop(self, node, parent):
+    def visit_unaryop(self, node, parent, assign_ctx=None):
         """visit a UnaryOp node by returning a fresh instance of it"""
         newnode = new.UnaryOp()
         _lineno_parent(node, newnode, parent)
-        newnode.operand = self.visit(node.operand, newnode)
+        newnode.operand = self.visit(node.operand, newnode, assign_ctx)
         newnode.op = _UNARY_OP_CLASSES[node.op.__class__]
         return newnode
 
-    def visit_while(self, node, parent):
+    def visit_while(self, node, parent, assign_ctx=None):
         """visit a While node by returning a fresh instance of it"""
         newnode = new.While()
         _lineno_parent(node, newnode, parent)
-        newnode.test = self.visit(node.test, newnode)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.orelse = [self.visit(child, newnode) for child in node.orelse]
+        newnode.test = self.visit(node.test, newnode, assign_ctx)
+        newnode.body = [self.visit(child, newnode, assign_ctx)
+                        for child in node.body]
+        newnode.orelse = [self.visit(child, newnode, assign_ctx)
+                          for child in node.orelse]
         return newnode
 
-    def visit_with(self, node, parent):
+    def visit_with(self, node, parent, assign_ctx=None):
         newnode = new.With()
         _lineno_parent(node, newnode, parent)
-        expr = self.visit(node.context_expr, newnode)
-        self.asscontext = "Ass"
+        expr = self.visit(node.context_expr, newnode, assign_ctx)
         if node.optional_vars is not None:
-            vars = self.visit(node.optional_vars, newnode)
+            vars = self.visit(node.optional_vars, newnode, 'Assign')
         else:
             vars = None
         self.asscontext = None
         newnode.items = [(expr, vars)]
-        newnode.body = [self.visit(child, newnode) for child in node.body]
+        newnode.body = [self.visit(child, newnode, assign_ctx)
+                        for child in node.body]
         return newnode
 
-    def visit_yield(self, node, parent):
+    def visit_yield(self, node, parent, assign_ctx=None):
         """visit a Yield node by returning a fresh instance of it"""
         return _create_yield_node(node, parent, self, new.Yield)
 
 class TreeRebuilder3k(TreeRebuilder):
     """extend and overwrite TreeRebuilder for python3k"""
 
-    def visit_arg(self, node, parent):
+    def visit_arg(self, node, parent, assign_ctx=None):
         """visit a arg node by returning a fresh AssName instance"""
-        # the <arg> node is coming from py>=3.0, but we use AssName in py2.x
-        # XXX or we should instead introduce a Arg node in astroid ?
-        return self.visit_assname(node, parent, node.arg)
+        # TODO(cpopa): introduce an Arg node instead of using AssignName.
+        return self.visit_assignname(node, parent, assign_ctx, node.arg)
 
-    def visit_nameconstant(self, node, parent):
+    def visit_nameconstant(self, node, parent, assign_ctx=None):
         # in Python 3.4 we have NameConstant for True / False / None
         newnode = new.Const(node.value)
         _set_infos(node, newnode, parent)
         return newnode
 
-    def visit_arguments(self, node, parent):
-        newnode = super(TreeRebuilder3k, self).visit_arguments(node, parent)
-        self.asscontext = "Ass"
-        newnode.kwonlyargs = [self.visit(child, newnode) for child in node.kwonlyargs]
-        self.asscontext = None
-        newnode.kw_defaults = [self.visit(child, newnode) if child else None for child in node.kw_defaults]
+    def visit_arguments(self, node, parent, assign_ctx=None):
+        newnode = super(TreeRebuilder3k, self).visit_arguments(node, parent, assign_ctx)
+        newnode.kwonlyargs = [self.visit(child, newnode, 'Assign')
+                              for child in node.kwonlyargs]
+        newnode.kw_defaults = [self.visit(child, newnode, None)
+                               if child else None for child in node.kw_defaults]
         newnode.annotations = [
-            self.visit(arg.annotation, newnode) if arg.annotation else None
+            self.visit(arg.annotation, newnode, None) if arg.annotation else None
             for arg in node.args]
         return newnode
 
-    def visit_excepthandler(self, node, parent):
+    def visit_excepthandler(self, node, parent, assign_ctx=None):
         """visit an ExceptHandler node by returning a fresh instance of it"""
         newnode = new.ExceptHandler()
         _lineno_parent(node, newnode, parent)
         if node.type is not None:
-            newnode.type = self.visit(node.type, newnode)
+            newnode.type = self.visit(node.type, newnode, assign_ctx)
         if node.name is not None:
-            newnode.name = self.visit_assname(node, newnode, node.name)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
+            newnode.name = self.visit_assignname(node, newnode, 'Assign', node.name)
+        newnode.body = [self.visit(child, newnode, None)
+                        for child in node.body]
         return newnode
 
-    def visit_nonlocal(self, node, parent):
+    def visit_nonlocal(self, node, parent, assign_ctx=None):
         """visit a Nonlocal node and return a new instance of it"""
         newnode = new.Nonlocal(node.names)
         _set_infos(node, newnode, parent)
         return newnode
 
-    def visit_raise(self, node, parent):
+    def visit_raise(self, node, parent, assign_ctx=None):
         """visit a Raise node by returning a fresh instance of it"""
         newnode = new.Raise()
         _lineno_parent(node, newnode, parent)
         # no traceback; anyway it is not used in Pylint
         if node.exc is not None:
-            newnode.exc = self.visit(node.exc, newnode)
+            newnode.exc = self.visit(node.exc, newnode, assign_ctx)
         if node.cause is not None:
-            newnode.cause = self.visit(node.cause, newnode)
+            newnode.cause = self.visit(node.cause, newnode, assign_ctx)
         return newnode
 
-    def visit_starred(self, node, parent):
+    def visit_starred(self, node, parent, assign_ctx=None):
         """visit a Starred node and return a new instance of it"""
         newnode = new.Starred()
         _lineno_parent(node, newnode, parent)
-        newnode.value = self.visit(node.value, newnode)
+        newnode.value = self.visit(node.value, newnode, assign_ctx)
         return newnode
 
-    def visit_try(self, node, parent):
+    def visit_try(self, node, parent, assign_ctx=None):
         # python 3.3 introduce a new Try node replacing TryFinally/TryExcept nodes
+        # pylint: disable=redefined-variable-type
         if node.finalbody:
             newnode = new.TryFinally()
             _lineno_parent(node, newnode, parent)
-            newnode.finalbody = [self.visit(n, newnode) for n in node.finalbody]
+            newnode.finalbody = [self.visit(n, newnode, assign_ctx)
+                                 for n in node.finalbody]
             if node.handlers:
                 excnode = new.TryExcept()
                 _lineno_parent(node, excnode, newnode)
-                excnode.body = [self.visit(child, excnode) for child in node.body]
-                excnode.handlers = [self.visit(child, excnode) for child in node.handlers]
-                excnode.orelse = [self.visit(child, excnode) for child in node.orelse]
+                excnode.body = [self.visit(child, excnode, assign_ctx)
+                                for child in node.body]
+                excnode.handlers = [self.visit(child, excnode, assign_ctx)
+                                    for child in node.handlers]
+                excnode.orelse = [self.visit(child, excnode, assign_ctx)
+                                  for child in node.orelse]
                 newnode.body = [excnode]
             else:
-                newnode.body = [self.visit(child, newnode) for child in node.body]
+                newnode.body = [self.visit(child, newnode, assign_ctx)
+                                for child in node.body]
         elif node.handlers:
             newnode = new.TryExcept()
             _lineno_parent(node, newnode, parent)
-            newnode.body = [self.visit(child, newnode) for child in node.body]
-            newnode.handlers = [self.visit(child, newnode) for child in node.handlers]
-            newnode.orelse = [self.visit(child, newnode) for child in node.orelse]
+            newnode.body = [self.visit(child, newnode, assign_ctx)
+                            for child in node.body]
+            newnode.handlers = [self.visit(child, newnode, assign_ctx)
+                                for child in node.handlers]
+            newnode.orelse = [self.visit(child, newnode, assign_ctx)
+                              for child in node.orelse]
         return newnode
 
-    def visit_with(self, node, parent):
+    def _visit_with(self, cls, node, parent, assign_ctx=None):
         if 'items' not in node._fields:
             # python < 3.3
-            return super(TreeRebuilder3k, self).visit_with(node, parent)
+            return super(TreeRebuilder3k, self).visit_with(node, parent,
+                                                           assign_ctx)
 
-        newnode = new.With()
+        newnode = cls()
         _lineno_parent(node, newnode, parent)
         def visit_child(child):
             expr = self.visit(child.context_expr, newnode)
-            self.asscontext = 'Ass'
             if child.optional_vars:
-                var = self.visit(child.optional_vars, newnode)
+                var = self.visit(child.optional_vars, newnode,
+                                 'Assign')
             else:
                 var = None
-            self.asscontext = None
             return expr, var
         newnode.items = [visit_child(child)
                          for child in node.items]
-        newnode.body = [self.visit(child, newnode) for child in node.body]
+        newnode.body = [self.visit(child, newnode, None)
+                        for child in node.body]
         return newnode
 
-    def visit_yieldfrom(self, node, parent):
+    def visit_with(self, node, parent, assign_ctx=None):
+        return self._visit_with(new.With, node, parent, assign_ctx=assign_ctx)
+
+    def visit_yieldfrom(self, node, parent, assign_ctx=None):
         return _create_yield_node(node, parent, self, new.YieldFrom)
 
-    def visit_class(self, node, parent):
-        newnode = super(TreeRebuilder3k, self).visit_class(node, parent)
+    def visit_classdef(self, node, parent, assign_ctx=None):
+        newnode = super(TreeRebuilder3k, self).visit_classdef(node, parent, assign_ctx)
         newnode._newstyle = True
         for keyword in node.keywords:
             if keyword.arg == 'metaclass':
-                newnode._metaclass = self.visit(keyword, newnode).value
+                newnode._metaclass = self.visit(keyword, newnode, assign_ctx).value
                 break
         return newnode
 
-if sys.version_info >= (3, 0):
-    TreeRebuilder = TreeRebuilder3k
+    # Async structs added in Python 3.5
+    def visit_asyncfunctiondef(self, node, parent, assign_ctx=None):
+        return self._visit_functiondef(new.AsyncFunctionDef, node, parent,
+                                       assign_ctx=assign_ctx)
 
 
+    def visit_asyncfor(self, node, parent, assign_ctx=None):
+        return self._visit_for(new.AsyncFor, node, parent,
+                               assign_ctx=assign_ctx)
+
+    def visit_await(self, node, parent, assign_ctx=None):
+        newnode = new.Await()
+        newnode.lineno = node.lineno
+        newnode.col_offset = node.col_offset
+        newnode.parent = parent
+        newnode.value = self.visit(node.value, newnode, None)
+        return newnode
+
+    def visit_asyncwith(self, node, parent, assign_ctx=None):
+        return self._visit_with(new.AsyncWith, node, parent,
+                                assign_ctx=assign_ctx)
+
+
+if sys.version_info >= (3, 0):
+    TreeRebuilder = TreeRebuilder3k